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 2022/06/01 05:25:04 UTC
[datasketches-memory17] branch main updated: Interm 4. All tests updated and pass.
This is an automated email from the ASF dual-hosted git repository.
leerho pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/datasketches-memory17.git
The following commit(s) were added to refs/heads/main by this push:
new cf4b4dc Interm 4. All tests updated and pass.
cf4b4dc is described below
commit cf4b4dc767a93c686f5e0cd44988593b88b063a2
Author: Lee Rhodes <le...@users.noreply.github.com>
AuthorDate: Tue May 31 22:24:59 2022 -0700
Interm 4. All tests updated and pass.
Tests moved to memory/internal package.
---
pom.xml | 9 +
.../org/apache/datasketches/memory/BaseState.java | 32 +-
.../org/apache/datasketches/memory/Buffer.java | 5 +-
.../org/apache/datasketches/memory/Memory.java | 13 +-
.../datasketches/memory/MemoryCloseException.java | 49 -
.../apache/datasketches/memory/MurmurHash3.java | 169 +++
.../apache/datasketches/memory/WritableBuffer.java | 2 +-
.../org/apache/datasketches/memory/XxHash.java | 2 +-
.../memory/internal/BaseStateImpl.java | 14 +-
.../memory/internal/BaseWritableBufferImpl.java | 79 +-
.../memory/internal/BaseWritableMemoryImpl.java | 59 +-
.../memory/internal/MurmurHash3v3.java | 28 +-
.../org/apache/datasketches/memory/UtilTest.java | 204 ----
.../AllocateDirectMapMemoryTest.java | 3 +-
.../{ => internal}/AllocateDirectMemoryTest.java | 6 +-
.../AllocateDirectWritableMapMemoryTest.java | 10 +-
.../memory/{ => internal}/BaseBufferTest.java | 7 +-
.../memory/{ => internal}/BaseStateTest.java | 7 +-
.../memory/{ => internal}/Buffer2Test.java | 6 +-
.../{ => internal}/BufferBoundaryCheckTest.java | 3 +-
.../{ => internal}/BufferInvariantsTest.java | 7 +-
.../{ => internal}/BufferReadWriteSafetyTest.java | 5 +-
.../memory/{ => internal}/BufferTest.java | 9 +-
.../memory/{ => internal}/CommonBufferTest.java | 6 +-
.../memory/{ => internal}/CommonMemoryTest.java | 5 +-
.../{ => internal}/CopyMemoryOverlapTest.java | 6 +-
.../memory/{ => internal}/CopyMemoryTest.java | 6 +-
.../memory/{ => internal}/DruidIssue11544Test.java | 5 +-
.../ExampleMemoryRequestServerTest.java | 6 +-
.../{ => internal}/IgnoredArrayOverflowTest.java | 5 +-
.../memory/{ => internal}/LeafImplTest.java | 6 +-
.../MemoryBoundaryCheckTest.java} | 95 +-
.../memory/internal/MemoryReadWriteSafetyTest.java | 216 ++++
.../datasketches/memory/internal/MemoryTest.java | 431 ++++++++
.../memory/internal/MemoryWriteToTest.java | 101 ++
.../memory/internal/MurmurHash3v3Test.java | 404 ++++++++
.../internal/NativeWritableBufferImplTest.java | 569 ++++++++++
.../internal/NativeWritableMemoryImplTest.java | 689 +++++++++++++
.../internal/NonNativeWritableBufferImplTest.java | 279 +++++
.../internal/NonNativeWritableMemoryImplTest.java | 176 ++++
.../memory/internal/SpecificLeafTest.java | 197 ++++
.../memory/{test => internal}/UtilTest.java | 3 +-
.../memory/internal/WritableDirectCopyTest.java | 253 +++++
.../memory/internal/WritableMemoryTest.java | 183 ++++
.../memory/internal/XxHash64LoopingTest.java | 1082 ++++++++++++++++++++
.../datasketches/memory/internal/XxHash64Test.java | 179 ++++
.../memory/internal/ZeroCapacityTest.java | 76 ++
.../datasketches/memory/test/ReflectUtil.java | 399 --------
48 files changed, 5274 insertions(+), 831 deletions(-)
diff --git a/pom.xml b/pom.xml
index eba2337..7abc060 100644
--- a/pom.xml
+++ b/pom.xml
@@ -170,6 +170,15 @@ under the License.
</snapshots>
</repository>
</repositories>
+
+ <dependencies>
+ <dependency>
+ <!-- Used for xxHash testing -->
+ <groupId>net.openhft</groupId>
+ <artifactId>zero-allocation-hashing</artifactId>
+ <scope>test</scope>
+ </dependency>
+ </dependencies>
<dependencyManagement>
<dependencies>
diff --git a/src/main/java/org/apache/datasketches/memory/BaseState.java b/src/main/java/org/apache/datasketches/memory/BaseState.java
index c9c8503..ff86e47 100644
--- a/src/main/java/org/apache/datasketches/memory/BaseState.java
+++ b/src/main/java/org/apache/datasketches/memory/BaseState.java
@@ -108,7 +108,7 @@ public interface BaseState /* extends AutoCloseable */ {
* this object in the given range of bytes. This will also check two distinct ranges within the
* same object for equals.
* @param thisOffsetBytes the starting offset in bytes for this object.
- * @param that the given object
+ * @param that the given BaseState object
* @param thatOffsetBytes the starting offset in bytes for the given object
* @param lengthBytes the size of the range in bytes
* @return true if the given object has equal contents to this object in the given range of
@@ -118,20 +118,36 @@ public interface BaseState /* extends AutoCloseable */ {
long thatOffsetBytes, long lengthBytes);
/**
- * Wraps the underlying MemorySegment in a ByteBuffer.
- * @see MemorySegment#asByteBuffer
- *
- * @return a ByteBuffer view of this memory segment.
- *
+ * Returns a ByteBuffer view of this Memory object with the given ByteOrder.
+ * Some of the properties of the returned buffer are linked to the properties of this Memory object.
+ * For instance, if this Memory object is immutable (i.e., read-only, see isReadOnly()),
+ * then the resulting buffer is read-only (see Buffer.isReadOnly().
+ * Additionally, if this is a native memory segment, the resulting buffer is direct
+ * (see ByteBuffer.isDirect()). The endianness of the returned buffer will be set to
+ * the given ByteOrder.
+ * @param order the given ByteOrder.
+ * @return a ByteBuffer view of this Memory object with the given ByteOrder.
+ * @throws UnsupportedOperationException - if this segment cannot be mapped onto a ByteBuffer instance,
+ * e.g. because it models an heap-based segment that is not based on a byte[]),
+ * or if its size is greater than Integer.MAX_VALUE.
+ */
+ ByteBuffer asByteBufferView(ByteOrder order);
+
+ /**
+ * Returns a new ByteBuffer with a copy of the data from this Memory object.
+ * This new ByteBuffer will be writable, on heap, and with the endianness specified
+ * by the given ByteOrder.
+ * @param order the given ByteOrder.
+ * @return a new ByteBuffer with a copy of the data from this Memory object.
*/
- ByteBuffer asByteBuffer();
+ ByteBuffer toByteBuffer(ByteOrder order);
/**
* Returns a copy of the underlying MemorySegment.
* The size is limited to <i>Integer.MAX_VALUE</i>.
* @return a copy of the underlying MemorySegment
*/
- MemorySegment asMemorySegment();
+ MemorySegment toMemorySegment();
/**
* Gets the capacity of this object in bytes
diff --git a/src/main/java/org/apache/datasketches/memory/Buffer.java b/src/main/java/org/apache/datasketches/memory/Buffer.java
index 7c5661d..fd19a4f 100644
--- a/src/main/java/org/apache/datasketches/memory/Buffer.java
+++ b/src/main/java/org/apache/datasketches/memory/Buffer.java
@@ -83,7 +83,10 @@ public interface Buffer extends BaseBuffer {
* @return a read-only duplicate view of this Buffer with the same but independent values of
* <i>start</i>, <i>position</i> and <i>end</i>.
*/
- Buffer duplicate();
+ default Buffer duplicate() {
+ return duplicate(getTypeByteOrder());
+ }
+
/**
* Returns a read-only duplicate view of this Buffer with the same but independent values of
diff --git a/src/main/java/org/apache/datasketches/memory/Memory.java b/src/main/java/org/apache/datasketches/memory/Memory.java
index 07e3135..437515c 100644
--- a/src/main/java/org/apache/datasketches/memory/Memory.java
+++ b/src/main/java/org/apache/datasketches/memory/Memory.java
@@ -19,11 +19,11 @@
package org.apache.datasketches.memory;
+import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
-import java.nio.channels.WritableByteChannel;
import java.util.Objects;
import org.apache.datasketches.memory.internal.BaseWritableMemoryImpl;
@@ -122,7 +122,7 @@ public interface Memory extends BaseState {
* offsetBytes and capacityBytes.
*/
default Memory region(long offsetBytes, long capacityBytes) {
- return region(offsetBytes, capacityBytes, ByteOrder.nativeOrder());
+ return region(offsetBytes, capacityBytes, getTypeByteOrder());
}
/**
@@ -154,7 +154,7 @@ public interface Memory extends BaseState {
* @return a new <i>Buffer</i>
*/
default Buffer asBuffer() {
- return asBuffer(ByteOrder.nativeOrder());
+ return asBuffer(getTypeByteOrder());
}
/**
@@ -391,7 +391,7 @@ public interface Memory extends BaseState {
*/
void getShortArray(long offsetBytes, short[] dstArray, int dstOffsetShorts, int lengthShorts);
- //SPECIAL PRIMITIVE READ METHODS: compareTo, copyTo, writeTo
+ //SPECIAL READ METHODS: compareTo, copyTo, writeTo
/**
* Compares the bytes of this Memory to <i>that</i> Memory.
@@ -428,10 +428,11 @@ public interface Memory extends BaseState {
* Writes bytes from a source range of this Memory to the given {@code WritableByteChannel}.
* @param offsetBytes the source offset for this Memory
* @param lengthBytes the number of bytes to copy
- * @param out the destination WritableByteChannel
+ * @param out the destination ByteArrayOutputStream
* @throws IOException may occur while writing to the WritableByteChannel
*/
- void writeTo(long offsetBytes, long lengthBytes, WritableByteChannel out)
+ void writeToByteStream(long offsetBytes, int lengthBytes, ByteArrayOutputStream out)
throws IOException;
+
}
diff --git a/src/main/java/org/apache/datasketches/memory/MemoryCloseException.java b/src/main/java/org/apache/datasketches/memory/MemoryCloseException.java
deleted file mode 100644
index 782c6cd..0000000
--- a/src/main/java/org/apache/datasketches/memory/MemoryCloseException.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package org.apache.datasketches.memory;
-
-/**
- * Specific RuntimeException for the AutoCloseable.close() method.
- *
- * @author Lee Rhodes
- *
- */
-public class MemoryCloseException extends MemoryException {
- private static final long serialVersionUID = 2L;
-
- /**
- * The associated resource failed to close.
- */
- public MemoryCloseException() {
- super("The associated resource failed to close.");
- }
-
- /**
- * The associated resource failed to close, with comment
- *
- * @param resource the named resource that failed to close, plus other comments.
- */
- public MemoryCloseException(final String resource) {
- super("The associated resource, " + resource + ", failed to close");
- }
-
-}
-
-
diff --git a/src/main/java/org/apache/datasketches/memory/MurmurHash3.java b/src/main/java/org/apache/datasketches/memory/MurmurHash3.java
new file mode 100644
index 0000000..69fd6a5
--- /dev/null
+++ b/src/main/java/org/apache/datasketches/memory/MurmurHash3.java
@@ -0,0 +1,169 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.datasketches.memory;
+
+import org.apache.datasketches.memory.internal.MurmurHash3v3;
+
+import jdk.incubator.foreign.MemorySegment;
+
+/**
+ * <p>The MurmurHash3 is a fast, non-cryptographic, 128-bit hash function that has
+ * excellent avalanche and 2-way bit independence properties.</p>
+ *
+ * <p>Austin Appleby's C++
+ * <a href="https://github.com/aappleby/smhasher/blob/master/src/MurmurHash3.cpp">
+ * MurmurHash3_x64_128(...), final revision 150</a>,
+ * which is in the Public Domain, was the inspiration for this implementation in Java.</p>
+ *
+ * <p>This implementation of the MurmurHash3 allows hashing of a block of on-heap Memory defined by an offset
+ * and length. The calling API also allows the user to supply the small output array of two longs,
+ * so that the entire hash function is static and free of object allocations.</p>
+ *
+ * <p>This implementation produces exactly the same hash result as the
+ * MurmurHash3 function in datasketches-java given compatible inputs.</p>
+ *
+ * * <p>This version 3 of the implementation leverages the jdk.incubator.foreign package of JDK-17 in place of
+ * the Unsafe class.
+ *
+ * @author Lee Rhodes
+ */
+public final class MurmurHash3 {
+
+ //Provided for backward compatibility
+
+ /**
+ * Returns a 128-bit hash of the input.
+ * Provided for compatibility with older version of MurmurHash3,
+ * but empty or null input now throws IllegalArgumentException.
+ * @param in long array
+ * @param seed A long valued seed.
+ * @return the hash
+ */
+ public static long[] hash(final long[] in, final long seed) {
+ return MurmurHash3v3.hash(in, seed);
+ }
+
+ /**
+ * Returns a 128-bit hash of the input.
+ * Provided for compatibility with older version of MurmurHash3,
+ * but empty or null input now throws IllegalArgumentException.
+ * @param in int array
+ * @param seed A long valued seed.
+ * @return the hash
+ */
+ public static long[] hash(final int[] in, final long seed) {
+ return MurmurHash3v3.hash(in, seed);
+ }
+
+ /**
+ * Returns a 128-bit hash of the input.
+ * Provided for compatibility with older version of MurmurHash3,
+ * but empty or null input now throws IllegalArgumentException.
+ * @param in char array
+ * @param seed A long valued seed.
+ * @return the hash
+ */
+ public static long[] hash(final char[] in, final long seed) {
+ return MurmurHash3v3.hash(in, seed);
+ }
+
+ /**
+ * Returns a 128-bit hash of the input.
+ * Provided for compatibility with older version of MurmurHash3,
+ * but empty or null input now throws IllegalArgumentException.
+ * @param in byte array
+ * @param seed A long valued seed.
+ * @return the hash
+ */
+ public static long[] hash(final byte[] in, final long seed) {
+ return MurmurHash3v3.hash(in, seed);
+ }
+
+ //Single primitive inputs
+
+ /**
+ * Returns a 128-bit hash of the input.
+ * Note the entropy of the resulting hash cannot be more than 64 bits.
+ * @param in a long
+ * @param seed A long valued seed.
+ * @param hashOut A long array of size 2
+ * @return the hash
+ */
+ public static long[] hash(final long in, final long seed, final long[] hashOut) {
+ return MurmurHash3v3.hash(in, seed, hashOut);
+ }
+
+ /**
+ * Returns a 128-bit hash of the input.
+ * Note the entropy of the resulting hash cannot be more than 64 bits.
+ * @param in a double
+ * @param seed A long valued seed.
+ * @param hashOut A long array of size 2
+ * @return the hash
+ */
+ public static long[] hash(final double in, final long seed, final long[] hashOut) {
+ return MurmurHash3v3.hash(in, seed, hashOut);
+ }
+
+ /**
+ * Returns a 128-bit hash of the input.
+ * An empty or null input throws IllegalArgumentException.
+ * @param in a String
+ * @param seed A long valued seed.
+ * @param hashOut A long array of size 2
+ * @return the hash
+ */
+ public static long[] hash(final String in, final long seed, final long[] hashOut) {
+ return MurmurHash3v3.hash(in, seed, hashOut);
+ }
+
+ //The main API calls
+
+ /**
+ * Returns a 128-bit hash of the input as a long array of size 2.
+ *
+ * @param mem The input on-heap Memory. Must be non-null and non-empty.
+ * @param offsetBytes the starting point within Memory.
+ * @param lengthBytes the total number of bytes to be hashed.
+ * @param seed A long valued seed.
+ * @param hashOut the size 2 long array for the resulting 128-bit hash
+ * @return the hash.
+ */
+ public static long[] hash(final Memory mem, final long offsetBytes, final long lengthBytes,
+ final long seed, final long[] hashOut) {
+ return MurmurHash3v3.hash(mem, offsetBytes, lengthBytes, seed, hashOut);
+ }
+
+ /**
+ * Returns a 128-bit hash of the input as a long array of size 2.
+ *
+ * @param seg The input MemorySegment. Must be non-null and non-empty.
+ * @param offsetBytes the starting point within Memory.
+ * @param lengthBytes the total number of bytes to be hashed.
+ * @param seed A long valued seed.
+ * @param hashOut the size 2 long array for the resulting 128-bit hash
+ * @return the hash.
+ */
+ public static long[] hash(final MemorySegment seg, final long offsetBytes, final long lengthBytes,
+ final long seed, final long[] hashOut) {
+ return MurmurHash3v3.hash(seg, offsetBytes, lengthBytes, seed, hashOut);
+ }
+
+}
diff --git a/src/main/java/org/apache/datasketches/memory/WritableBuffer.java b/src/main/java/org/apache/datasketches/memory/WritableBuffer.java
index 362a38e..1d2ca70 100644
--- a/src/main/java/org/apache/datasketches/memory/WritableBuffer.java
+++ b/src/main/java/org/apache/datasketches/memory/WritableBuffer.java
@@ -122,7 +122,7 @@ public interface WritableBuffer extends Buffer {
* @return a new <i>WritableBuffer</i> representing the defined writable region.
*/
default WritableBuffer writableRegion() {
- return writableRegion(getPosition(), getEnd() - getPosition(), ByteOrder.nativeOrder());
+ return writableRegion(getPosition(), getEnd() - getPosition(), getTypeByteOrder());
}
/**
diff --git a/src/main/java/org/apache/datasketches/memory/XxHash.java b/src/main/java/org/apache/datasketches/memory/XxHash.java
index b657b82..2aae9c0 100644
--- a/src/main/java/org/apache/datasketches/memory/XxHash.java
+++ b/src/main/java/org/apache/datasketches/memory/XxHash.java
@@ -127,7 +127,7 @@ public final class XxHash {
* @param seed A long valued seed.
* @return the hash.
*/
- public static long hashLong(final int in, final int seed) {
+ public static long hashLong(final long in, final int seed) {
return hash(in, seed);
}
diff --git a/src/main/java/org/apache/datasketches/memory/internal/BaseStateImpl.java b/src/main/java/org/apache/datasketches/memory/internal/BaseStateImpl.java
index 2159ef5..f7b8cb6 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/BaseStateImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BaseStateImpl.java
@@ -23,6 +23,7 @@ import static jdk.incubator.foreign.MemoryAccess.getByteAtOffset;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
+import java.util.Objects;
import org.apache.datasketches.memory.BaseState;
import org.apache.datasketches.memory.MemoryRequestServer;
@@ -181,12 +182,19 @@ public abstract class BaseStateImpl implements BaseState {
}
@Override
- public ByteBuffer asByteBuffer() {
- return seg.asByteBuffer();
+ public final ByteBuffer asByteBufferView(final ByteOrder order) {
+ final ByteBuffer byteBuf = seg.asByteBuffer().order(order);
+ return byteBuf;
}
@Override
- public MemorySegment asMemorySegment() {
+ public ByteBuffer toByteBuffer(ByteOrder order) {
+ Objects.requireNonNull(order, "The input ByteOrder must not be null");
+ return ByteBuffer.wrap(seg.toByteArray());
+ }
+
+ @Override
+ public MemorySegment toMemorySegment() {
MemorySegment arrSeg = MemorySegment.ofArray(new byte[(int)seg.byteSize()]);
arrSeg.copyFrom(seg);
return arrSeg;
diff --git a/src/main/java/org/apache/datasketches/memory/internal/BaseWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/BaseWritableBufferImpl.java
index 7fd1b77..7002053 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/BaseWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BaseWritableBufferImpl.java
@@ -60,7 +60,7 @@ public abstract class BaseWritableBufferImpl extends BaseBufferImpl implements W
super(seg, typeId);
}
- //HEAP ARRAYS
+ //HEAP ARRAY RESOURCE
public static WritableBuffer wrapSegmentAsArray(
final MemorySegment seg,
@@ -76,8 +76,7 @@ public abstract class BaseWritableBufferImpl extends BaseBufferImpl implements W
return new HeapNonNativeWritableBufferImpl(seg, type, memReqSvr);
}
-
- //BYTE BUFFER
+ //BYTE BUFFER RESOURCE
public static WritableBuffer wrapByteBuffer(
final ByteBuffer byteBuffer,
@@ -88,8 +87,8 @@ public abstract class BaseWritableBufferImpl extends BaseBufferImpl implements W
MemorySegment seg = MemorySegment.ofByteBuffer(byteBuf); //from 0 to capacity
int type = BUFFER | BYTEBUF
| (localReadOnly ? READONLY : 0)
- | (seg.isMapped() ? MAP : 0)
- | (seg.isNative() ? DIRECT : 0);
+ | (seg.isNative() ? DIRECT : 0)
+ | (seg.isMapped() ? MAP : 0);
if (byteOrder == ByteOrder.nativeOrder()) {
type |= NATIVE;
final WritableBuffer wbuf = new BBWritableBufferImpl(seg, type);
@@ -102,10 +101,10 @@ public abstract class BaseWritableBufferImpl extends BaseBufferImpl implements W
return wbuf;
}
- //NO MAP
- //NO DIRECTS
+ //NO MAP RESOURCE
+ //NO DIRECT RESOURCE
- //REGIONS
+ //REGIONS DERIVED
@Override
public Buffer region(final long offsetBytes, final long capacityBytes, final ByteOrder byteOrder) {
@@ -191,6 +190,7 @@ public abstract class BaseWritableBufferImpl extends BaseBufferImpl implements W
if (!this.isAlive()) { throw new IllegalStateException("This Memory is not alive."); }
final boolean readOnly = isReadOnly() || localReadOnly;
final MemorySegment seg2 = (readOnly && !seg.isReadOnly()) ? seg.asReadOnly() : seg;
+ final boolean regionType = isRegionType();
final boolean duplicateType = true;
final boolean mapType = seg.isMapped();
final boolean directType = seg.isNative();
@@ -198,6 +198,7 @@ public abstract class BaseWritableBufferImpl extends BaseBufferImpl implements W
final boolean byteBufferType = isByteBufferType();
final int type = BUFFER
| (readOnly ? READONLY : 0)
+ | (regionType ? REGION : 0)
| (duplicateType ? DUPLICATE : 0)
| (mapType ? MAP : 0)
| (directType ? DIRECT : 0)
@@ -206,37 +207,25 @@ public abstract class BaseWritableBufferImpl extends BaseBufferImpl implements W
WritableBuffer wbuf;
if (byteBufferType) {
- if (nativeBOType) {
- wbuf = new BBWritableBufferImpl(seg2, type);
- } else {
- wbuf = new BBNonNativeWritableBufferImpl(seg2, type);
- }
+ if (nativeBOType) { wbuf = new BBWritableBufferImpl(seg2, type); }
+ else { wbuf = new BBNonNativeWritableBufferImpl(seg2, type); }
}
if (mapType) {
- if (nativeBOType) {
- wbuf = new MapWritableBufferImpl(seg2, type);
- } else {
- wbuf = new MapNonNativeWritableBufferImpl(seg2, type);
- }
+ if (nativeBOType) { wbuf = new MapWritableBufferImpl(seg2, type); }
+ else { wbuf = new MapNonNativeWritableBufferImpl(seg2, type); }
}
if (directType) {
- if (nativeBOType) {
- wbuf = new DirectWritableBufferImpl(seg2, type, memReqSvr);
- } else {
- wbuf = new DirectNonNativeWritableBufferImpl(seg2, type, memReqSvr);
- }
+ if (nativeBOType) { wbuf = new DirectWritableBufferImpl(seg2, type, memReqSvr); }
+ else { wbuf = new DirectNonNativeWritableBufferImpl(seg2, type, memReqSvr); }
}
//else heap type
- if (nativeBOType) {
- wbuf = new HeapWritableBufferImpl(seg2, type, memReqSvr);
- } else {
- wbuf = new HeapNonNativeWritableBufferImpl(seg2, type, memReqSvr);
- }
+ if (nativeBOType) { wbuf = new HeapWritableBufferImpl(seg2, type, memReqSvr); }
+ else { wbuf = new HeapNonNativeWritableBufferImpl(seg2, type, memReqSvr); }
wbuf.setStartPositionEnd(getStart(), getPosition(), getEnd());
return wbuf;
}
- //AS MEMORY
+ //AS MEMORY DERIVED
@Override
public Memory asMemory(final ByteOrder byteOrder) {
@@ -257,6 +246,7 @@ public abstract class BaseWritableBufferImpl extends BaseBufferImpl implements W
Objects.requireNonNull(byteOrder, "byteOrder must be non-null");
final boolean readOnly = isReadOnly() || localReadOnly;
final MemorySegment seg2 = (readOnly && !seg.isReadOnly()) ? seg.asReadOnly() : seg;
+ final boolean regionType = isRegionType();
final boolean duplicateType = isDuplicateType();
final boolean mapType = seg.isMapped();
final boolean directType = seg.isNative();
@@ -264,6 +254,7 @@ public abstract class BaseWritableBufferImpl extends BaseBufferImpl implements W
final boolean byteBufferType = isByteBufferType();
final int type = MEMORY
| (readOnly ? READONLY : 0)
+ | (regionType ? REGION : 0)
| (duplicateType ? DUPLICATE : 0)
| (mapType ? MAP : 0)
| (directType ? DIRECT : 0)
@@ -271,32 +262,20 @@ public abstract class BaseWritableBufferImpl extends BaseBufferImpl implements W
| (byteBufferType ? BYTEBUF : 0);
WritableMemory wmem;
if (byteBufferType) {
- if (nativeBOType) {
- wmem = new BBWritableMemoryImpl(seg2, type);
- } else {
- wmem = new BBNonNativeWritableMemoryImpl(seg2, type);
- }
+ if (nativeBOType) { wmem = new BBWritableMemoryImpl(seg2, type); }
+ else { wmem = new BBNonNativeWritableMemoryImpl(seg2, type);}
}
if (mapType) {
- if (nativeBOType) {
- wmem = new MapWritableMemoryImpl(seg2, type);
- } else {
- wmem = new MapNonNativeWritableMemoryImpl(seg2, type);
- }
+ if (nativeBOType) { wmem = new MapWritableMemoryImpl(seg2, type); }
+ else { wmem = new MapNonNativeWritableMemoryImpl(seg2, type); }
}
if (directType) {
- if (nativeBOType) {
- wmem = new DirectWritableMemoryImpl(seg2, type, memReqSvr);
- } else {
- wmem = new DirectNonNativeWritableMemoryImpl(seg2, type, memReqSvr);
- }
+ if (nativeBOType) { wmem = new DirectWritableMemoryImpl(seg2, type, memReqSvr); }
+ else { wmem = new DirectNonNativeWritableMemoryImpl(seg2, type, memReqSvr); }
}
//else heap type
- if (nativeBOType) {
- wmem = new HeapWritableMemoryImpl(seg2, type, memReqSvr);
- } else {
- wmem = new HeapNonNativeWritableMemoryImpl(seg2, type, memReqSvr);
- }
+ if (nativeBOType) { wmem = new HeapWritableMemoryImpl(seg2, type, memReqSvr); }
+ else { wmem = new HeapNonNativeWritableMemoryImpl(seg2, type, memReqSvr); }
return wmem;
}
@@ -325,7 +304,7 @@ public abstract class BaseWritableBufferImpl extends BaseBufferImpl implements W
setPosition(pos + lengthBytes);
}
- //OTHER PRIMITIVE READ METHODS: copyTo, compareTo. No writeTo
+ //OTHER PRIMITIVE READ METHODS: e.g., copyTo, compareTo. No writeTo
@Override
public final int compareTo(final long thisOffsetBytes, final long thisLengthBytes,
diff --git a/src/main/java/org/apache/datasketches/memory/internal/BaseWritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/BaseWritableMemoryImpl.java
index d9454a0..2b9f052 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/BaseWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BaseWritableMemoryImpl.java
@@ -22,12 +22,12 @@ package org.apache.datasketches.memory.internal;
import static java.nio.channels.FileChannel.MapMode.READ_ONLY;
import static java.nio.channels.FileChannel.MapMode.READ_WRITE;
+import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.FileChannel;
-import java.nio.channels.WritableByteChannel;
import java.util.Objects;
import org.apache.datasketches.memory.Buffer;
@@ -66,7 +66,7 @@ public abstract class BaseWritableMemoryImpl extends BaseStateImpl implements Wr
super(seg, typeId);
}
- //HEAP ARRAYS
+ //HEAP ARRAY RESOURCE
public static WritableMemory wrapSegmentAsArray(
final MemorySegment seg,
@@ -82,7 +82,7 @@ public abstract class BaseWritableMemoryImpl extends BaseStateImpl implements Wr
return new HeapNonNativeWritableMemoryImpl(seg, type, memReqSvr);
}
- //BYTE BUFFER
+ //BYTE BUFFER RESOURCE
public static WritableMemory wrapByteBuffer(
final ByteBuffer byteBuffer,
@@ -93,8 +93,8 @@ public abstract class BaseWritableMemoryImpl extends BaseStateImpl implements Wr
MemorySegment seg = MemorySegment.ofByteBuffer(byteBuf); //from 0 to capacity
int type = MEMORY | BYTEBUF
| (localReadOnly ? READONLY : 0)
- | (seg.isMapped() ? MAP : 0)
- | (seg.isNative() ? DIRECT : 0);
+ | (seg.isNative() ? DIRECT : 0)
+ | (seg.isMapped() ? MAP : 0);
if (byteOrder == ByteOrder.nativeOrder()) {
type |= NATIVE;
return new BBWritableMemoryImpl(seg, type);
@@ -103,7 +103,7 @@ public abstract class BaseWritableMemoryImpl extends BaseStateImpl implements Wr
return new BBNonNativeWritableMemoryImpl(seg, type);
}
- //MAP
+ //MAP RESOURCE
/**
* Maps the specified portion of the given file into Memory for write operations.
@@ -145,7 +145,7 @@ public abstract class BaseWritableMemoryImpl extends BaseStateImpl implements Wr
: new MapNonNativeWritableMemoryImpl(seg, type);
}
- //DIRECT
+ //DIRECT RESOURCE
/**
* The static constructor that chooses the correct Direct leaf node based on the byte order.
@@ -177,7 +177,7 @@ public abstract class BaseWritableMemoryImpl extends BaseStateImpl implements Wr
: new DirectNonNativeWritableMemoryImpl(seg, type, memReqSvr);
}
- //REGIONS
+ //REGION DERIVED
@Override
public Memory region(final long offsetBytes, final long capacityBytes, final ByteOrder byteOrder) {
@@ -232,7 +232,7 @@ public abstract class BaseWritableMemoryImpl extends BaseStateImpl implements Wr
return new HeapNonNativeWritableMemoryImpl(slice, type, memReqSvr);
}
- //AS BUFFER
+ //AS BUFFER DERIVED
@Override
public Buffer asBuffer(final ByteOrder byteOrder) {
@@ -253,6 +253,7 @@ public abstract class BaseWritableMemoryImpl extends BaseStateImpl implements Wr
Objects.requireNonNull(byteOrder, "byteOrder must be non-null");
final boolean readOnly = isReadOnly() || localReadOnly;
final MemorySegment seg2 = (readOnly && !seg.isReadOnly()) ? seg.asReadOnly() : seg;
+ final boolean regionType = isRegionType();
final boolean duplicateType = isDuplicateType();
final boolean mapType = seg.isMapped();
final boolean directType = seg.isNative();
@@ -260,39 +261,28 @@ public abstract class BaseWritableMemoryImpl extends BaseStateImpl implements Wr
final boolean byteBufferType = isByteBufferType();
final int type = BUFFER
| (readOnly ? READONLY : 0)
+ | (regionType ? REGION : 0)
| (duplicateType ? DUPLICATE : 0)
- | (mapType ? MAP : 0)
| (directType ? DIRECT : 0)
+ | (mapType ? MAP : 0)
| (nativeBOType ? NATIVE : NONNATIVE)
| (byteBufferType ? BYTEBUF : 0);
WritableBuffer wbuf;
if (byteBufferType) {
- if (nativeBOType) {
- wbuf = new BBWritableBufferImpl(seg2, type);
- } else {
- wbuf = new BBNonNativeWritableBufferImpl(seg2, type);
- }
+ if (nativeBOType) { wbuf = new BBWritableBufferImpl(seg2, type); }
+ else { wbuf = new BBNonNativeWritableBufferImpl(seg2, type); }
}
if (mapType) {
- if (nativeBOType) {
- wbuf = new MapWritableBufferImpl(seg2, type);
- } else {
- wbuf = new MapNonNativeWritableBufferImpl(seg2, type);
- }
+ if (nativeBOType) { wbuf = new MapWritableBufferImpl(seg2, type); }
+ else { wbuf = new MapNonNativeWritableBufferImpl(seg2, type); }
}
if (directType) {
- if (nativeBOType) {
- wbuf = new DirectWritableBufferImpl(seg2, type, memReqSvr);
- } else {
- wbuf = new DirectNonNativeWritableBufferImpl(seg2, type, memReqSvr);
- }
+ if (nativeBOType) { wbuf = new DirectWritableBufferImpl(seg2, type, memReqSvr); }
+ else { wbuf = new DirectNonNativeWritableBufferImpl(seg2, type, memReqSvr); }
}
//else heap type
- if (nativeBOType) {
- wbuf = new HeapWritableBufferImpl(seg2, type, memReqSvr);
- } else {
- wbuf = new HeapNonNativeWritableBufferImpl(seg2, type, memReqSvr);
- }
+ if (nativeBOType) { wbuf = new HeapWritableBufferImpl(seg2, type, memReqSvr); }
+ else { wbuf = new HeapNonNativeWritableBufferImpl(seg2, type, memReqSvr); }
wbuf.setStartPositionEnd(0, 0, getCapacity());
return wbuf;
}
@@ -330,11 +320,12 @@ public abstract class BaseWritableMemoryImpl extends BaseStateImpl implements Wr
}
@Override
- public final void writeTo(final long offsetBytes, final long lengthBytes,
- final WritableByteChannel out) throws IOException {
+ public final void writeToByteStream(final long offsetBytes, final int lengthBytes,
+ final ByteArrayOutputStream out) throws IOException {
checkBounds(offsetBytes, lengthBytes, seg.byteSize());
- ByteBuffer bb = seg.asSlice(offsetBytes, lengthBytes).asByteBuffer();
- out.write(bb);
+ final byte[] bArr = new byte[lengthBytes];
+ getByteArray(offsetBytes,bArr, 0, lengthBytes); //fundamental limitation of MemorySegment
+ out.writeBytes(bArr);
}
// //PRIMITIVE putX() and putXArray() implementations
diff --git a/src/main/java/org/apache/datasketches/memory/internal/MurmurHash3v3.java b/src/main/java/org/apache/datasketches/memory/internal/MurmurHash3v3.java
index 906046c..e53311b 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/MurmurHash3v3.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/MurmurHash3v3.java
@@ -23,6 +23,8 @@ import static java.nio.charset.StandardCharsets.UTF_8;
import java.util.Objects;
+import org.apache.datasketches.memory.Memory;
+
import jdk.incubator.foreign.MemoryAccess;
import jdk.incubator.foreign.MemorySegment;
@@ -51,8 +53,6 @@ public final class MurmurHash3v3 {
private static final long C1 = 0x87c37b91114253d5L;
private static final long C2 = 0x4cf5ad432745937fL;
-
-
/**
* Returns a 128-bit hash of the input.
* Provided for compatibility with older version of MurmurHash3,
@@ -161,12 +161,30 @@ public final class MurmurHash3v3 {
return hash(MemorySegment.ofArray(byteArr), 0L, byteArr.length, seed, hashOut);
}
- //The main API call
+ //The main API calls
/**
* Returns a 128-bit hash of the input as a long array of size 2.
*
- * @param seg The input on-heap Memory. Must be non-null and non-empty,
+ * @param mem The input Memory. Must be non-null and non-empty,
+ * otherwise throws IllegalArgumentException.
+ * @param offsetBytes the starting point within Memory.
+ * @param lengthBytes the total number of bytes to be hashed.
+ * @param seed A long valued seed.
+ * @param hashOut the size 2 long array for the resulting 128-bit hash
+ * @return the hash.
+ */
+ public static long[] hash(final Memory mem, final long offsetBytes, final long lengthBytes,
+ final long seed, final long[] hashOut) {
+ Objects.requireNonNull(mem, "Input Memory is null");
+ MemorySegment seg = ((BaseStateImpl)mem).seg;
+ return hash(seg, offsetBytes, lengthBytes, seed, hashOut);
+ }
+
+ /**
+ * Returns a 128-bit hash of the input as a long array of size 2.
+ *
+ * @param seg The input MemorySegment. Must be non-null and non-empty,
* otherwise throws IllegalArgumentException.
* @param offsetBytes the starting point within Memory.
* @param lengthBytes the total number of bytes to be hashed.
@@ -174,13 +192,11 @@ public final class MurmurHash3v3 {
* @param hashOut the size 2 long array for the resulting 128-bit hash
* @return the hash.
*/
- @SuppressWarnings("restriction")
public static long[] hash(final MemorySegment seg, final long offsetBytes, final long lengthBytes,
final long seed, final long[] hashOut) {
Objects.requireNonNull(seg, "Input MemorySegment is null");
if (seg.byteSize() == 0L) { throw new IllegalArgumentException("Input MemorySegment is empty."); }
-
long cumOff = offsetBytes;
long h1 = seed;
diff --git a/src/test/java/org/apache/datasketches/memory/UtilTest.java b/src/test/java/org/apache/datasketches/memory/UtilTest.java
deleted file mode 100644
index 46bffa4..0000000
--- a/src/test/java/org/apache/datasketches/memory/UtilTest.java
+++ /dev/null
@@ -1,204 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-/*
- * Note: Lincoln's Gettysburg Address is in the public domain. See LICENSE.
- */
-
-package org.apache.datasketches.memory;
-
-import static org.apache.datasketches.memory.internal.Util.characterPad;
-import static org.apache.datasketches.memory.internal.Util.getResourceBytes;
-import static org.apache.datasketches.memory.internal.Util.getResourceFile;
-import static org.apache.datasketches.memory.internal.Util.negativeCheck;
-import static org.apache.datasketches.memory.internal.Util.nullCheck;
-import static org.apache.datasketches.memory.internal.Util.zeroCheck;
-import static org.apache.datasketches.memory.internal.Util.zeroPad;
-import static org.testng.Assert.assertEquals;
-import static org.testng.Assert.assertTrue;
-import static org.testng.Assert.fail;
-
-import java.io.File;
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.LinkOption;
-import java.nio.file.attribute.PosixFileAttributeView;
-import java.nio.file.attribute.PosixFileAttributes;
-import java.nio.file.attribute.PosixFilePermissions;
-
-import org.apache.datasketches.memory.internal.Util;
-import org.testng.annotations.Test;
-
-public class UtilTest {
- private static final String LS = System.getProperty("line.separator");
-
- //Binary Search
- @Test
- public void checkBinarySearch() {
- int k = 1024; //longs
- WritableMemory wMem = WritableMemory.allocate(k << 3); //1024 longs
- 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);
- assertEquals(idx, k/2);
- assertEquals(val, k/2);
-
- idx = Util.binarySearchLongs(wMem, 0, k - 1, k);
- assertEquals(idx, -1024);
- }
-
-// @Test(expectedExceptions = IllegalArgumentException.class)
-// public void checkBoundsTest() {
-// UnsafeUtil.checkBounds(999, 2, 1000);
-// }
-
- @Test
- public void checkPadding() {
- String s = "123";
- String t = zeroPad(s, 4);
- assertTrue(t.startsWith("0"));
-
- t = characterPad(s, 4, '0', true);
- assertTrue(t.endsWith("0"));
-
- t = characterPad(s, 3, '0', false);
- assertEquals(s, t);
- }
-
- @Test
- public void checkNullZeroNegativeChecks() {
- Object obj = null;
- try {
- nullCheck(obj, "Test Object");
- fail();
- } catch (IllegalArgumentException e) {
- //OK
- }
- try {
- zeroCheck(0, "Test Long");
- fail();
- } catch (IllegalArgumentException e) {
- //OK
- }
- try {
- negativeCheck(-1L, "Test Long");
- fail();
- } catch (IllegalArgumentException e) {
- //OK
- }
- }
-
- @Test
- public void checkCodePointArr() {
- final Util.RandomCodePoints rvcp = new Util.RandomCodePoints(true);
- final int n = 1000;
- final int[] cpArr = new int[n];
- rvcp.fillCodePointArray(cpArr);
- for (int i = 0; i < n; i++) {
- int cp = cpArr[i];
- if ((cp >= Character.MIN_SURROGATE) && (cp <= Character.MAX_SURROGATE)) {
- fail();
- }
- }
- }
-
- @Test
- public void checkCodePoint() {
- final Util.RandomCodePoints rvcp = new Util.RandomCodePoints(true);
- final int n = 1000;
- for (int i = 0; i < n; i++) {
- int cp = rvcp.getCodePoint();
- if ((cp >= Character.MIN_SURROGATE) && (cp <= Character.MAX_SURROGATE)) {
- fail();
- }
- }
- }
-
- static final String getFileAttributes(File file) {
- try {
- PosixFileAttributes attrs = Files.getFileAttributeView(
- file.toPath(), PosixFileAttributeView.class, new LinkOption[0]).readAttributes();
- String s = String.format("%s: %s %s %s%n",
- file.getPath(),
- attrs.owner().getName(),
- attrs.group().getName(),
- PosixFilePermissions.toString(attrs.permissions()));
- return s;
- } catch (IOException e) {
- throw new RuntimeException(e);
- }
- }
-
- static final void setGettysburgAddressFileToReadOnly() {
- File file = getResourceFile("GettysburgAddress.txt");
- try {
- Files.setPosixFilePermissions(file.toPath(), PosixFilePermissions.fromString("r--r--r--"));
- } catch (IOException e) {
- throw new RuntimeException(e);
- }
- }
-
- //Resources
-
- @Test
- public void resourceFileExits() {
- final String shortFileName = "GettysburgAddress.txt";
- final File file = getResourceFile(shortFileName);
- assertTrue(file.exists());
- }
-
- @Test(expectedExceptions = NullPointerException.class)
- public void resourceFileNotFound() {
- final String shortFileName = "GettysburgAddress.txt";
- getResourceFile(shortFileName + "123");
- }
-
- @Test
- public void resourceBytesCorrect() {
- final String shortFileName = "GettysburgAddress.txt";
- final byte[] bytes = getResourceBytes(shortFileName);
- assertTrue(bytes.length == 1541);
- }
-
- @Test(expectedExceptions = NullPointerException.class)
- public void resourceBytesFileNotFound() {
- final String shortFileName = "GettysburgAddress.txt";
- getResourceBytes(shortFileName + "123");
- }
-
- @Test
- public void printlnTest() {
- println("PRINTING: "+this.getClass().getName());
- }
-
- static void println(final Object o) {
- if (o == null) { print(LS); }
- else { print(o.toString() + LS); }
- }
-
- /**
- * @param o value to print
- */
- static void print(final Object o) {
- if (o != null) {
- //System.out.print(o.toString()); //disable here
- }
- }
-
-}
diff --git a/src/test/java/org/apache/datasketches/memory/AllocateDirectMapMemoryTest.java b/src/test/java/org/apache/datasketches/memory/internal/AllocateDirectMapMemoryTest.java
similarity index 97%
rename from src/test/java/org/apache/datasketches/memory/AllocateDirectMapMemoryTest.java
rename to src/test/java/org/apache/datasketches/memory/internal/AllocateDirectMapMemoryTest.java
index 5b8b0e7..0b5c35e 100644
--- a/src/test/java/org/apache/datasketches/memory/AllocateDirectMapMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/AllocateDirectMapMemoryTest.java
@@ -21,7 +21,7 @@
* Note: Lincoln's Gettysburg Address is in the public domain. See LICENSE.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import static org.apache.datasketches.memory.internal.Util.*;
import static org.testng.Assert.assertEquals;
@@ -32,6 +32,7 @@ import static org.testng.Assert.fail;
import java.io.File;
import java.nio.ByteOrder;
+import org.apache.datasketches.memory.Memory;
import org.testng.annotations.Test;
import jdk.incubator.foreign.ResourceScope;
diff --git a/src/test/java/org/apache/datasketches/memory/AllocateDirectMemoryTest.java b/src/test/java/org/apache/datasketches/memory/internal/AllocateDirectMemoryTest.java
similarity index 93%
rename from src/test/java/org/apache/datasketches/memory/AllocateDirectMemoryTest.java
rename to src/test/java/org/apache/datasketches/memory/internal/AllocateDirectMemoryTest.java
index 6c61ac3..ceb6d67 100644
--- a/src/test/java/org/apache/datasketches/memory/AllocateDirectMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/AllocateDirectMemoryTest.java
@@ -17,12 +17,16 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
+import org.apache.datasketches.memory.BaseState;
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
import jdk.incubator.foreign.ResourceScope;
diff --git a/src/test/java/org/apache/datasketches/memory/AllocateDirectWritableMapMemoryTest.java b/src/test/java/org/apache/datasketches/memory/internal/AllocateDirectWritableMapMemoryTest.java
similarity index 94%
rename from src/test/java/org/apache/datasketches/memory/AllocateDirectWritableMapMemoryTest.java
rename to src/test/java/org/apache/datasketches/memory/internal/AllocateDirectWritableMapMemoryTest.java
index 266c195..a04a68d 100644
--- a/src/test/java/org/apache/datasketches/memory/AllocateDirectWritableMapMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/AllocateDirectWritableMapMemoryTest.java
@@ -21,7 +21,7 @@
* Note: Lincoln's Gettysburg Address is in the public domain. See LICENSE.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.apache.datasketches.memory.internal.Util.getResourceFile;
@@ -36,6 +36,12 @@ import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.nio.ByteOrder;
+import org.apache.datasketches.memory.BaseState;
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.ReadOnlyException;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
@@ -82,7 +88,7 @@ public class AllocateDirectWritableMapMemoryTest {
assertTrue (file.isFile());
file.deleteOnExit(); //comment out if you want to examine the file.
- WritableMemory dstMem = null;
+ WritableMemory dstMem = null;
try (ResourceScope scope = ResourceScope.newConfinedScope()) { //this scope manages two Memory objects
dstMem = WritableMemory.writableMap(file, 0, numBytes, scope, ByteOrder.nativeOrder());
diff --git a/src/test/java/org/apache/datasketches/memory/BaseBufferTest.java b/src/test/java/org/apache/datasketches/memory/internal/BaseBufferTest.java
similarity index 88%
rename from src/test/java/org/apache/datasketches/memory/BaseBufferTest.java
rename to src/test/java/org/apache/datasketches/memory/internal/BaseBufferTest.java
index 625b1d8..b8ccac8 100644
--- a/src/test/java/org/apache/datasketches/memory/BaseBufferTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/BaseBufferTest.java
@@ -17,10 +17,15 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import static org.testng.Assert.fail;
+import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
import jdk.incubator.foreign.ResourceScope;
diff --git a/src/test/java/org/apache/datasketches/memory/BaseStateTest.java b/src/test/java/org/apache/datasketches/memory/internal/BaseStateTest.java
similarity index 92%
rename from src/test/java/org/apache/datasketches/memory/BaseStateTest.java
rename to src/test/java/org/apache/datasketches/memory/internal/BaseStateTest.java
index b848065..d0cf39a 100644
--- a/src/test/java/org/apache/datasketches/memory/BaseStateTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/BaseStateTest.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
@@ -25,7 +25,10 @@ import static org.testng.Assert.fail;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.internal.BaseStateImpl;
+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;
public class BaseStateTest {
diff --git a/src/test/java/org/apache/datasketches/memory/Buffer2Test.java b/src/test/java/org/apache/datasketches/memory/internal/Buffer2Test.java
similarity index 97%
rename from src/test/java/org/apache/datasketches/memory/Buffer2Test.java
rename to src/test/java/org/apache/datasketches/memory/internal/Buffer2Test.java
index f0729c9..1317271 100644
--- a/src/test/java/org/apache/datasketches/memory/Buffer2Test.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/Buffer2Test.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
@@ -27,6 +27,10 @@ import static org.testng.Assert.assertTrue;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
+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;
public class Buffer2Test {
diff --git a/src/test/java/org/apache/datasketches/memory/BufferBoundaryCheckTest.java b/src/test/java/org/apache/datasketches/memory/internal/BufferBoundaryCheckTest.java
similarity index 97%
copy from src/test/java/org/apache/datasketches/memory/BufferBoundaryCheckTest.java
copy to src/test/java/org/apache/datasketches/memory/internal/BufferBoundaryCheckTest.java
index b90d685..9eb6f75 100644
--- a/src/test/java/org/apache/datasketches/memory/BufferBoundaryCheckTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/BufferBoundaryCheckTest.java
@@ -17,8 +17,9 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
public class BufferBoundaryCheckTest {
diff --git a/src/test/java/org/apache/datasketches/memory/BufferInvariantsTest.java b/src/test/java/org/apache/datasketches/memory/internal/BufferInvariantsTest.java
similarity index 96%
rename from src/test/java/org/apache/datasketches/memory/BufferInvariantsTest.java
rename to src/test/java/org/apache/datasketches/memory/internal/BufferInvariantsTest.java
index 36e1ff9..e90cd29 100644
--- a/src/test/java/org/apache/datasketches/memory/BufferInvariantsTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/BufferInvariantsTest.java
@@ -17,13 +17,18 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.fail;
import java.nio.ByteBuffer;
+import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
import jdk.incubator.foreign.ResourceScope;
diff --git a/src/test/java/org/apache/datasketches/memory/BufferReadWriteSafetyTest.java b/src/test/java/org/apache/datasketches/memory/internal/BufferReadWriteSafetyTest.java
similarity index 96%
rename from src/test/java/org/apache/datasketches/memory/BufferReadWriteSafetyTest.java
rename to src/test/java/org/apache/datasketches/memory/internal/BufferReadWriteSafetyTest.java
index 8588b14..4e375d6 100644
--- a/src/test/java/org/apache/datasketches/memory/BufferReadWriteSafetyTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/BufferReadWriteSafetyTest.java
@@ -17,10 +17,13 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import java.nio.ByteBuffer;
+import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
public class BufferReadWriteSafetyTest {
diff --git a/src/test/java/org/apache/datasketches/memory/BufferTest.java b/src/test/java/org/apache/datasketches/memory/internal/BufferTest.java
similarity index 95%
rename from src/test/java/org/apache/datasketches/memory/BufferTest.java
rename to src/test/java/org/apache/datasketches/memory/internal/BufferTest.java
index dcc794f..49797ec 100644
--- a/src/test/java/org/apache/datasketches/memory/BufferTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/BufferTest.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import static org.testng.Assert.assertEquals;
@@ -25,6 +25,13 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
+import org.apache.datasketches.memory.BaseState;
+import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
import org.testng.collections.Lists;
diff --git a/src/test/java/org/apache/datasketches/memory/CommonBufferTest.java b/src/test/java/org/apache/datasketches/memory/internal/CommonBufferTest.java
similarity index 98%
rename from src/test/java/org/apache/datasketches/memory/CommonBufferTest.java
rename to src/test/java/org/apache/datasketches/memory/internal/CommonBufferTest.java
index e6e24df..34e48d4 100644
--- a/src/test/java/org/apache/datasketches/memory/CommonBufferTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/CommonBufferTest.java
@@ -17,10 +17,14 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import static org.testng.Assert.assertEquals;
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
import jdk.incubator.foreign.ResourceScope;
diff --git a/src/test/java/org/apache/datasketches/memory/CommonMemoryTest.java b/src/test/java/org/apache/datasketches/memory/internal/CommonMemoryTest.java
similarity index 98%
rename from src/test/java/org/apache/datasketches/memory/CommonMemoryTest.java
rename to src/test/java/org/apache/datasketches/memory/internal/CommonMemoryTest.java
index 43c3c32..5f402ce 100644
--- a/src/test/java/org/apache/datasketches/memory/CommonMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/CommonMemoryTest.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import static org.apache.datasketches.memory.internal.Util.isAllBitsClear;
import static org.apache.datasketches.memory.internal.Util.isAllBitsSet;
@@ -27,6 +27,9 @@ import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
import jdk.incubator.foreign.ResourceScope;
diff --git a/src/test/java/org/apache/datasketches/memory/CopyMemoryOverlapTest.java b/src/test/java/org/apache/datasketches/memory/internal/CopyMemoryOverlapTest.java
similarity index 95%
rename from src/test/java/org/apache/datasketches/memory/CopyMemoryOverlapTest.java
rename to src/test/java/org/apache/datasketches/memory/internal/CopyMemoryOverlapTest.java
index f89847d..d7ec28b 100644
--- a/src/test/java/org/apache/datasketches/memory/CopyMemoryOverlapTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/CopyMemoryOverlapTest.java
@@ -17,10 +17,14 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import static org.testng.Assert.assertEquals;
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
import jdk.incubator.foreign.ResourceScope;
diff --git a/src/test/java/org/apache/datasketches/memory/CopyMemoryTest.java b/src/test/java/org/apache/datasketches/memory/internal/CopyMemoryTest.java
similarity index 95%
rename from src/test/java/org/apache/datasketches/memory/CopyMemoryTest.java
rename to src/test/java/org/apache/datasketches/memory/internal/CopyMemoryTest.java
index 7665b14..6ca469f 100644
--- a/src/test/java/org/apache/datasketches/memory/CopyMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/CopyMemoryTest.java
@@ -17,12 +17,16 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import static org.testng.Assert.assertEquals;
import java.util.concurrent.ThreadLocalRandom;
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.Assert;
import org.testng.annotations.Test;
diff --git a/src/test/java/org/apache/datasketches/memory/DruidIssue11544Test.java b/src/test/java/org/apache/datasketches/memory/internal/DruidIssue11544Test.java
similarity index 93%
rename from src/test/java/org/apache/datasketches/memory/DruidIssue11544Test.java
rename to src/test/java/org/apache/datasketches/memory/internal/DruidIssue11544Test.java
index 911606b..43dafac 100644
--- a/src/test/java/org/apache/datasketches/memory/DruidIssue11544Test.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/DruidIssue11544Test.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
@@ -27,6 +27,9 @@ import static org.testng.Assert.assertTrue;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
/**
diff --git a/src/test/java/org/apache/datasketches/memory/ExampleMemoryRequestServerTest.java b/src/test/java/org/apache/datasketches/memory/internal/ExampleMemoryRequestServerTest.java
similarity index 95%
rename from src/test/java/org/apache/datasketches/memory/ExampleMemoryRequestServerTest.java
rename to src/test/java/org/apache/datasketches/memory/internal/ExampleMemoryRequestServerTest.java
index 25fa2ee..9646968 100644
--- a/src/test/java/org/apache/datasketches/memory/ExampleMemoryRequestServerTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/ExampleMemoryRequestServerTest.java
@@ -17,10 +17,12 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
+import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
import jdk.incubator.foreign.ResourceScope;
@@ -131,6 +133,6 @@ public class ExampleMemoryRequestServerTest {
* @param o value to print
*/
static void println(Object o) {
- System.out.println(o); //disable here
+ //System.out.println(o); //disable here
}
}
diff --git a/src/test/java/org/apache/datasketches/memory/IgnoredArrayOverflowTest.java b/src/test/java/org/apache/datasketches/memory/internal/IgnoredArrayOverflowTest.java
similarity index 93%
rename from src/test/java/org/apache/datasketches/memory/IgnoredArrayOverflowTest.java
rename to src/test/java/org/apache/datasketches/memory/internal/IgnoredArrayOverflowTest.java
index bdae1bb..9d2bcf8 100644
--- a/src/test/java/org/apache/datasketches/memory/IgnoredArrayOverflowTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/IgnoredArrayOverflowTest.java
@@ -17,10 +17,13 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
diff --git a/src/test/java/org/apache/datasketches/memory/LeafImplTest.java b/src/test/java/org/apache/datasketches/memory/internal/LeafImplTest.java
similarity index 97%
rename from src/test/java/org/apache/datasketches/memory/LeafImplTest.java
rename to src/test/java/org/apache/datasketches/memory/internal/LeafImplTest.java
index c397452..4b2c71a 100644
--- a/src/test/java/org/apache/datasketches/memory/LeafImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/LeafImplTest.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
@@ -28,6 +28,10 @@ import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
+import org.apache.datasketches.memory.BaseState;
+import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
import jdk.incubator.foreign.ResourceScope;
diff --git a/src/test/java/org/apache/datasketches/memory/BufferBoundaryCheckTest.java b/src/test/java/org/apache/datasketches/memory/internal/MemoryBoundaryCheckTest.java
similarity index 55%
rename from src/test/java/org/apache/datasketches/memory/BufferBoundaryCheckTest.java
rename to src/test/java/org/apache/datasketches/memory/internal/MemoryBoundaryCheckTest.java
index b90d685..46b69d8 100644
--- a/src/test/java/org/apache/datasketches/memory/BufferBoundaryCheckTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/MemoryBoundaryCheckTest.java
@@ -17,20 +17,24 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
+import static org.testng.Assert.fail;
+
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
-public class BufferBoundaryCheckTest {
+public class MemoryBoundaryCheckTest {
- private final WritableMemory writableMemory = WritableMemory.allocate(8);
+ private final WritableBuffer writableBuffer = WritableMemory.allocate(8).asWritableBuffer();
@Test
public void testGetByte() {
- writableMemory.getByte(7);
+ writableBuffer.getByte(7);
try {
- writableMemory.getByte(8);
- throw new RuntimeException("Expected IndexOutOfBoundsException");
+ writableBuffer.getByte(8);
+ fail();
} catch (final IndexOutOfBoundsException expected) {
// ignore
}
@@ -38,10 +42,10 @@ public class BufferBoundaryCheckTest {
@Test
public void testPutByte() {
- writableMemory.putByte(7, (byte) 1);
+ writableBuffer.putByte(7, (byte) 1);
try {
- writableMemory.putByte(8, (byte) 1);
- throw new RuntimeException("Expected IndexOutOfBoundsException");
+ writableBuffer.putByte(8, (byte) 1);
+ fail();
} catch (final IndexOutOfBoundsException expected) {
// ignore
}
@@ -49,10 +53,10 @@ public class BufferBoundaryCheckTest {
@Test
public void testGetChar() {
- writableMemory.getChar(6);
+ writableBuffer.getChar(6);
try {
- writableMemory.getChar(7);
- throw new RuntimeException("Expected IndexOutOfBoundsException");
+ writableBuffer.getChar(7);
+ fail();
} catch (final IndexOutOfBoundsException expected) {
// ignore
}
@@ -60,10 +64,10 @@ public class BufferBoundaryCheckTest {
@Test
public void testPutChar() {
- writableMemory.putChar(6, 'a');
+ writableBuffer.putChar(6, 'a');
try {
- writableMemory.putChar(7, 'a');
- throw new RuntimeException("Expected IndexOutOfBoundsException");
+ writableBuffer.putChar(7, 'a');
+ fail();
} catch (final IndexOutOfBoundsException expected) {
// ignore
}
@@ -71,10 +75,10 @@ public class BufferBoundaryCheckTest {
@Test
public void testGetShort() {
- writableMemory.getShort(6);
+ writableBuffer.getShort(6);
try {
- writableMemory.getShort(7);
- throw new RuntimeException("Expected IndexOutOfBoundsException");
+ writableBuffer.getShort(7);
+ fail();
} catch (final IndexOutOfBoundsException expected) {
// ignore
}
@@ -82,10 +86,10 @@ public class BufferBoundaryCheckTest {
@Test
public void testPutShort() {
- writableMemory.putShort(6, (short) 1);
+ writableBuffer.putShort(6, (short) 1);
try {
- writableMemory.putShort(7, (short) 1);
- throw new RuntimeException("Expected IndexOutOfBoundsException");
+ writableBuffer.putShort(7, (short) 1);
+ fail();
} catch (final IndexOutOfBoundsException expected) {
// ignore
}
@@ -93,10 +97,10 @@ public class BufferBoundaryCheckTest {
@Test
public void testGetInt() {
- writableMemory.getInt(4);
+ writableBuffer.getInt(4);
try {
- writableMemory.getInt(5);
- throw new RuntimeException("Expected IndexOutOfBoundsException");
+ writableBuffer.getInt(5);
+ fail();
} catch (final IndexOutOfBoundsException expected) {
// ignore
}
@@ -104,10 +108,10 @@ public class BufferBoundaryCheckTest {
@Test
public void testPutInt() {
- writableMemory.putInt(4, 1);
+ writableBuffer.putInt(4, 1);
try {
- writableMemory.putInt(5, 1);
- throw new RuntimeException("Expected IndexOutOfBoundsException");
+ writableBuffer.putInt(5, 1);
+ fail();
} catch (final IndexOutOfBoundsException expected) {
// ignore
}
@@ -115,10 +119,10 @@ public class BufferBoundaryCheckTest {
@Test
public void testGetFloat() {
- writableMemory.getFloat(4);
+ writableBuffer.getFloat(4);
try {
- writableMemory.getFloat(5);
- throw new RuntimeException("Expected IndexOutOfBoundsException");
+ writableBuffer.getFloat(5);
+ fail();
} catch (final IndexOutOfBoundsException expected) {
// ignore
}
@@ -126,10 +130,10 @@ public class BufferBoundaryCheckTest {
@Test
public void testPutFloat() {
- writableMemory.putFloat(4, 1f);
+ writableBuffer.putFloat(4, 1f);
try {
- writableMemory.putFloat(5, 1f);
- throw new RuntimeException("Expected IndexOutOfBoundsException");
+ writableBuffer.putFloat(5, 1f);
+ fail();
} catch (final IndexOutOfBoundsException expected) {
// ignore
}
@@ -137,10 +141,10 @@ public class BufferBoundaryCheckTest {
@Test
public void testGetLong() {
- writableMemory.getLong(0);
+ writableBuffer.getLong(0);
try {
- writableMemory.getLong(1);
- throw new RuntimeException("Expected IndexOutOfBoundsException");
+ writableBuffer.getLong(1);
+ fail();
} catch (final IndexOutOfBoundsException expected) {
// ignore
}
@@ -148,10 +152,10 @@ public class BufferBoundaryCheckTest {
@Test
public void testPutLong() {
- writableMemory.putLong(0, 1L);
+ writableBuffer.putLong(0, 1L);
try {
- writableMemory.putLong(1, 1L);
- throw new RuntimeException("Expected IndexOutOfBoundsException");
+ writableBuffer.putLong(1, 1L);
+ fail();
} catch (final IndexOutOfBoundsException expected) {
// ignore
}
@@ -159,10 +163,10 @@ public class BufferBoundaryCheckTest {
@Test
public void testGetDouble() {
- writableMemory.getDouble(0);
+ writableBuffer.getDouble(0);
try {
- writableMemory.getDouble(1);
- throw new RuntimeException("Expected IndexOutOfBoundsException");
+ writableBuffer.getDouble(1);
+ fail();
} catch (final IndexOutOfBoundsException expected) {
// ignore
}
@@ -170,13 +174,12 @@ public class BufferBoundaryCheckTest {
@Test
public void testPutDouble() {
- writableMemory.putDouble(0, 1d);
+ writableBuffer.putDouble(0, 1d);
try {
- writableMemory.putDouble(1, 1d);
- throw new RuntimeException("Expected IndexOutOfBoundsException");
+ writableBuffer.putDouble(1, 1d);
+ fail();
} catch (final IndexOutOfBoundsException expected) {
// ignore
}
}
-
}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/MemoryReadWriteSafetyTest.java b/src/test/java/org/apache/datasketches/memory/internal/MemoryReadWriteSafetyTest.java
new file mode 100644
index 0000000..0b3b8fb
--- /dev/null
+++ b/src/test/java/org/apache/datasketches/memory/internal/MemoryReadWriteSafetyTest.java
@@ -0,0 +1,216 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.datasketches.memory.internal;
+
+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.Memory;
+import org.apache.datasketches.memory.WritableMemory;
+import org.testng.annotations.Test;
+
+import jdk.incubator.foreign.ResourceScope;
+
+public class MemoryReadWriteSafetyTest {
+
+ // Test various operations with read-only Memory
+
+ final WritableMemory mem = (WritableMemory) Memory.wrap(new byte[8]);
+
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testPutByte() {
+ mem.putByte(0, (byte) 1);
+ }
+
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testPutShort() {
+ mem.putShort(0, (short) 1);
+ }
+
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testPutChar() {
+ mem.putChar(0, (char) 1);
+ }
+
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testPutInt() {
+ mem.putInt(0, 1);
+ }
+
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testPutLong() {
+ mem.putLong(0, 1);
+ }
+
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testPutFloat() {
+ mem.putFloat(0, 1);
+ }
+
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testPutDouble() {
+ mem.putDouble(0, 1);
+ }
+
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testPutByteArray() {
+ mem.putByteArray(0, new byte[] {1}, 0, 1);
+ }
+
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testPutShortArray() {
+ mem.putShortArray(0, new short[] {1}, 0, 1);
+ }
+
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testPutCharArray() {
+ mem.putCharArray(0, new char[] {1}, 0, 1);
+ }
+
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testPutIntArray() {
+ mem.putIntArray(0, new int[] {1}, 0, 1);
+ }
+
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testPutLongArray() {
+ mem.putLongArray(0, new long[] {1}, 0, 1);
+ }
+
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testPutFloatArray() {
+ mem.putFloatArray(0, new float[] {1}, 0, 1);
+ }
+
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testDoubleByteArray() {
+ mem.putDoubleArray(0, new double[] {1}, 0, 1);
+ }
+
+ // Now, test that various ways to obtain a read-only memory produce a read-only memory indeed
+
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testWritableMemoryRegion() {
+ WritableMemory mem1 = (WritableMemory) WritableMemory.allocate(8).region(0, 8);
+ mem1.putInt(0, 1);
+ }
+
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testByteArrayWrap() {
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new byte[8]);
+ mem1.putInt(0, 1);
+ }
+
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testByteArrayWrapWithBO() {
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new byte[8], ByteOrder.nativeOrder());
+ mem1.putInt(0, 1);
+ }
+
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testByteArrayWrapWithOffsetsAndBO() {
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new byte[8], 0, 4, ByteOrder.nativeOrder());
+ mem1.putInt(0, 1);
+ }
+
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testShortArrayWrap() {
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new short[8]);
+ mem1.putInt(0, 1);
+ }
+
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testCharArrayWrap() {
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new char[8]);
+ mem1.putInt(0, 1);
+ }
+
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testIntArrayWrap() {
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new int[8]);
+ mem1.putInt(0, 1);
+ }
+
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testLongArrayWrap() {
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new long[8]);
+ mem1.putInt(0, 1);
+ }
+
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testFloatArrayWrap() {
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new float[8]);
+ mem1.putInt(0, 1);
+ }
+
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testDoubleArrayWrap() {
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new double[8]);
+ mem1.putInt(0, 1);
+ }
+
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testByteBufferWrap() {
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(ByteBuffer.allocate(8));
+ mem1.putInt(0, 1);
+ }
+
+ //@SuppressWarnings("resource")
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ 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 (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ Memory mem = Memory.map(tempFile, scope);
+ ((WritableMemory) mem).putInt(0, 1);
+ }
+ }
+ }
+
+ @SuppressWarnings("resource")
+ @Test(expectedExceptions = UnsupportedOperationException.class)
+ public void testMapFileWithOffsetsAndBO() throws Exception {
+ File tempFile = File.createTempFile("test", "test");
+ tempFile.deleteOnExit();
+ new RandomAccessFile(tempFile, "rw").setLength(8);
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ Memory mem = Memory.map(tempFile, 0, 4, scope, ByteOrder.nativeOrder());
+ ((WritableMemory) mem).putInt(0, 1);
+ }
+ }
+
+ @Test(expectedExceptions = IOException.class)
+ public void testMapFileBeyondTheFileSize() throws Exception {
+ File tempFile = File.createTempFile("test", "test");
+ tempFile.deleteOnExit();
+ try (RandomAccessFile raf = new RandomAccessFile(tempFile, "rw")) {
+ raf.setLength(8);
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ Memory.map(tempFile, 0, 16, scope, ByteOrder.nativeOrder());
+ }
+ }
+ }
+}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/MemoryTest.java b/src/test/java/org/apache/datasketches/memory/internal/MemoryTest.java
new file mode 100644
index 0000000..8404398
--- /dev/null
+++ b/src/test/java/org/apache/datasketches/memory/internal/MemoryTest.java
@@ -0,0 +1,431 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/*
+ * Note: Lincoln's Gettysburg Address is in the public domain. See LICENSE.
+ */
+
+package org.apache.datasketches.memory.internal;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertFalse;
+import static org.testng.Assert.assertNotNull;
+import static org.testng.Assert.assertNull;
+import static org.testng.Assert.assertTrue;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.List;
+
+import org.apache.datasketches.memory.BaseState;
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+import org.testng.collections.Lists;
+
+import jdk.incubator.foreign.ResourceScope;
+
+public class MemoryTest {
+ private static final String LS = System.getProperty("line.separator");
+ private final MemoryRequestServer memReqSvr = new DefaultMemoryRequestServer();
+
+
+ @BeforeClass
+ public void setReadOnly() {
+ UtilTest.setGettysburgAddressFileToReadOnly();
+ }
+
+ @Test
+ public void checkDirectRoundTrip() throws Exception {
+ int n = 1024; //longs
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory mem = WritableMemory.allocateDirect(n * 8, scope, memReqSvr);
+ for (int i = 0; i < n; i++) {
+ mem.putLong(i * 8, i);
+ }
+ for (int i = 0; i < n; i++) {
+ long v = mem.getLong(i * 8);
+ assertEquals(v, i);
+ }
+ }
+ }
+
+ @Test
+ public void checkAutoHeapRoundTrip() {
+ int n = 1024; //longs
+ WritableMemory wmem = WritableMemory.allocate(n * 8);
+ for (int i = 0; i < n; i++) {
+ wmem.putLong(i * 8, i);
+ }
+ for (int i = 0; i < n; i++) {
+ long v = wmem.getLong(i * 8);
+ assertEquals(v, i);
+ }
+ }
+
+ @Test
+ public void checkArrayWrap() {
+ int n = 1024; //longs
+ byte[] arr = new byte[n * 8];
+ WritableMemory wmem = WritableMemory.writableWrap(arr);
+ for (int i = 0; i < n; i++) {
+ wmem.putLong(i * 8, i);
+ }
+ for (int i = 0; i < n; i++) {
+ long v = wmem.getLong(i * 8);
+ assertEquals(v, i);
+ }
+ 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
+ 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(memZeroLengthArrayByte.getCapacity(), 0);
+ assertEquals(memZeroLengthArrayChar.getCapacity(), 0);
+ assertEquals(memZeroLengthArrayShort.getCapacity(), 0);
+ assertEquals(memZeroLengthArrayInt.getCapacity(), 0);
+ assertEquals(memZeroLengthArrayLong.getCapacity(), 0);
+ assertEquals(memZeroLengthArrayFloat.getCapacity(), 0);
+ assertEquals(memZeroLengthArrayDouble.getCapacity(), 0);
+
+ // check 0 length array wraps
+ List<Memory> memoryToCheck = Lists.newArrayList();
+ memoryToCheck.add(WritableMemory.allocate(0));
+ memoryToCheck.add(WritableMemory.writableWrap(ByteBuffer.allocate(0)));
+ memoryToCheck.add(WritableMemory.writableWrap(new 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 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);
+ }
+ }
+
+ @Test
+ public void checkByteBufHeap() {
+ int n = 1024; //longs
+ byte[] arr = new byte[n * 8];
+ ByteBuffer bb = ByteBuffer.wrap(arr);
+ bb.order(ByteOrder.nativeOrder());
+ WritableMemory wmem = WritableMemory.writableWrap(bb);
+ for (int i = 0; i < n; i++) { //write to wmem
+ wmem.putLong(i * 8, i);
+ }
+ for (int i = 0; i < n; i++) { //read from wmem
+ long v = wmem.getLong(i * 8);
+ assertEquals(v, i);
+ }
+ for (int i = 0; i < n; i++) { //read from BB
+ long v = bb.getLong(i * 8);
+ assertEquals(v, i);
+ }
+ 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
+ Memory mem = wmem;
+ for (int i = 0; i < n; i++) {
+ long v = mem.getLong(i * 8);
+ assertEquals(v, i);
+ }
+ }
+
+ @Test
+ public void checkByteBufDirect() {
+ int n = 1024; //longs
+ ByteBuffer bb = ByteBuffer.allocateDirect(n * 8);
+ bb.order(ByteOrder.nativeOrder());
+ WritableMemory wmem = WritableMemory.writableWrap(bb);
+ for (int i = 0; i < n; i++) { //write to wmem
+ wmem.putLong(i * 8, i);
+ }
+ for (int i = 0; i < n; i++) { //read from wmem
+ long v = wmem.getLong(i * 8);
+ assertEquals(v, i);
+ }
+ for (int i = 0; i < n; i++) { //read from BB
+ long v = bb.getLong(i * 8);
+ assertEquals(v, i);
+ }
+ 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
+ Memory mem = wmem;
+ for (int i = 0; i < n; i++) {
+ long v = mem.getLong(i * 8);
+ assertEquals(v, i);
+ }
+ }
+
+ @Test
+ public void checkByteBufOrderIgnored() {
+ int n = 1024; //longs
+ ByteBuffer bb = ByteBuffer.allocate(n * 8);
+ bb.order(ByteOrder.BIG_ENDIAN); //ignored
+ Memory mem = Memory.wrap(bb); //Defaults to LE
+ assertTrue(mem.getTypeByteOrder() == ByteOrder.nativeOrder());
+ assertEquals(mem.getTypeByteOrder(), ByteOrder.LITTLE_ENDIAN);
+ //Now explicitly set it
+ mem = Memory.wrap(bb, BaseState.NON_NATIVE_BYTE_ORDER);
+ assertFalse(mem.getTypeByteOrder() == ByteOrder.nativeOrder());
+ assertEquals(mem.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
+ }
+
+ @Test
+ public void checkReadOnlyHeapByteBuffer() {
+ ByteBuffer bb = ByteBuffer.allocate(128);
+ bb.order(ByteOrder.nativeOrder());
+ for (int i = 0; i < 128; i++) { bb.put(i, (byte)i); }
+ bb.position(64);
+ ByteBuffer slice = bb.slice().asReadOnlyBuffer();
+ slice.order(ByteOrder.nativeOrder());
+ Memory mem = Memory.wrap(slice);
+ for (int i = 0; i < 64; i++) {
+ assertEquals(mem.getByte(i), 64 + i);
+ }
+ mem.toHexString("slice", 0, slice.capacity(), true);
+ //println(s);
+ }
+
+ @Test
+ public void checkPutGetArraysHeap() {
+ int n = 1024; //longs
+ long[] arr = new long[n];
+ for (int i = 0; i < n; i++) { arr[i] = i; }
+ WritableMemory wmem = WritableMemory.allocate(n * 8);
+ wmem.putLongArray(0, arr, 0, n);
+ long[] arr2 = new long[n];
+ wmem.getLongArray(0, arr2, 0, n);
+ for (int i = 0; i < n; i++) {
+ assertEquals(arr2[i], i);
+ }
+ }
+
+ @Test
+ public void checkRORegions() {
+ int n = 16;
+ int n2 = n / 2;
+ long[] arr = new long[n];
+ for (int i = 0; i < n; i++) { arr[i] = i; }
+ Memory mem = Memory.wrap(arr);
+ Memory 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;
+ assertEquals(v, e);
+ }
+ }
+
+ @Test
+ public void checkRORegionsReverseBO() {
+ int n = 16;
+ int n2 = n / 2;
+ long[] arr = new long[n];
+ for (int i = 0; i < n; i++) { arr[i] = i; }
+ Memory mem = Memory.wrap(arr);
+ Memory reg = mem.region(n2 * 8, n2 * 8, BaseState.NON_NATIVE_BYTE_ORDER); //top half
+ for (int i = 0; i < n2; i++) {
+ long v = Long.reverseBytes(reg.getLong(i * 8));
+ long e = i + n2;
+ assertEquals(v, e);
+ }
+ }
+
+ @Test
+ public void checkWRegions() {
+ int n = 16;
+ int n2 = n / 2;
+ long[] arr = new long[n];
+ for (int i = 0; i < n; i++) { arr[i] = i; }
+ WritableMemory wmem = WritableMemory.writableWrap(arr);
+ for (int i = 0; i < n; i++) {
+ assertEquals(wmem.getLong(i * 8), i);
+ //println("" + wmem.getLong(i * 8));
+ }
+ //println("");
+ 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);
+ //println("" + wmem.getLong(i * 8));
+ }
+ }
+
+ @Test
+ public void checkWRegionsReverseBO() {
+ int n = 16;
+ int n2 = n / 2;
+ long[] arr = new long[n];
+ for (int i = 0; i < n; i++) { arr[i] = i; }
+ WritableMemory wmem = WritableMemory.writableWrap(arr);
+ for (int i = 0; i < n; i++) {
+ assertEquals(wmem.getLong(i * 8), i);
+ //println("" + wmem.getLong(i * 8));
+ }
+ //println("");
+ WritableMemory reg = wmem.writableRegion(n2 * 8, n2 * 8, BaseState.NON_NATIVE_BYTE_ORDER);
+ 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);
+ if (i < n2) {
+ assertEquals(v, i % 8);
+ } else {
+ assertEquals(Long.reverseBytes(v), i % 8);
+ }
+ //println("" + wmem.getLong(i * 8));
+ }
+ }
+
+ @SuppressWarnings("resource")
+ @Test(expectedExceptions = IllegalStateException.class)
+ public void checkParentUseAfterFree() throws Exception {
+ int bytes = 64 * 8;
+ ResourceScope scope = ResourceScope.newConfinedScope();
+ WritableMemory wmem = WritableMemory.allocateDirect(bytes, scope, memReqSvr);
+ wmem.close();
+ //with -ea assert: Memory not valid.
+ //with -da sometimes segfaults, sometimes passes!
+ wmem.getLong(0);
+ }
+
+ @SuppressWarnings("resource")
+ @Test(expectedExceptions = IllegalStateException.class)
+ public void checkRegionUseAfterFree() throws Exception {
+ int bytes = 64;
+ ResourceScope scope = ResourceScope.newConfinedScope();
+ WritableMemory wmem = WritableMemory.allocateDirect(bytes, scope, memReqSvr);
+ Memory region = wmem.region(0L, bytes);
+ wmem.close();
+ //with -ea assert: Memory not valid.
+ //with -da sometimes segfaults, sometimes passes!
+ region.getByte(0);
+ }
+
+ @Test
+ public void checkMemReqSvr() throws Exception {
+ WritableMemory wmem;
+ WritableBuffer wbuf;
+
+ //ON HEAP
+ wmem = WritableMemory.writableWrap(new byte[16]);
+ assertNull(wmem.getMemoryRequestServer());
+ wbuf = wmem.asWritableBuffer();
+ assertNull(wbuf.getMemoryRequestServer());
+ //OFF HEAP
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ wmem = WritableMemory.allocateDirect(16, scope, memReqSvr); //OFF HEAP
+ assertNotNull(wmem.getMemoryRequestServer());
+ wbuf = wmem.asWritableBuffer();
+ assertNotNull(wbuf.getMemoryRequestServer());
+ }
+ //ByteBuffer
+ ByteBuffer bb = ByteBuffer.allocate(16);
+ wmem = WritableMemory.writableWrap(bb);
+ assertNull(wmem.getMemoryRequestServer());
+ wbuf = wmem.asWritableBuffer();
+ assertNull(wbuf.getMemoryRequestServer());
+
+ //ON HEAP
+ wmem = WritableMemory.writableWrap(new byte[16], 0, 16, BaseState.NATIVE_BYTE_ORDER, memReqSvr);
+ assertNotNull(wmem.getMemoryRequestServer());
+ wbuf = wmem.asWritableBuffer();
+ assertNotNull(wbuf.getMemoryRequestServer());
+ //OFF HEAP
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory wmem2 = WritableMemory.allocateDirect(16, scope, memReqSvr);
+ assertNotNull(wmem2.getMemoryRequestServer());
+ wbuf = wmem.asWritableBuffer();
+ assertNotNull(wbuf.getMemoryRequestServer());
+ }
+ //ByteBuffer
+ bb = ByteBuffer.allocate(16);
+ wmem = WritableMemory.writableWrap(bb);
+ assertNull(wmem.getMemoryRequestServer());
+ wbuf = wmem.asWritableBuffer();
+ assertNull(wbuf.getMemoryRequestServer());
+ }
+
+ @Test
+ public void checkSelfEqualsToAndCompareTo() {
+ int len = 64;
+ 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));
+ assertEquals(wmem.compareTo(0, len, wmem, 0, len), 0);
+ assertTrue(wmem.compareTo(0, 0, wmem, len/2, len/2) < 0);
+ }
+
+ @Test
+ public void wrapBigEndianAsLittle() {
+ ByteBuffer bb = ByteBuffer.allocate(64);
+ bb.putChar(0, (char)1); //as NNO
+ Memory mem = Memory.wrap(bb, ByteOrder.LITTLE_ENDIAN);
+ assertEquals(mem.getChar(0), 256);
+ }
+
+ @Test
+ public void printlnTest() {
+ println("PRINTING: "+this.getClass().getName());
+ }
+
+ static void println(final Object o) {
+ if (o == null) { print(LS); }
+ else { print(o.toString() + LS); }
+ }
+
+ /**
+ * @param o value to print
+ */
+ static void print(final Object o) {
+ if (o != null) {
+ //System.out.print(o.toString()); //disable here
+ }
+ }
+
+}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/MemoryWriteToTest.java b/src/test/java/org/apache/datasketches/memory/internal/MemoryWriteToTest.java
new file mode 100644
index 0000000..c74a862
--- /dev/null
+++ b/src/test/java/org/apache/datasketches/memory/internal/MemoryWriteToTest.java
@@ -0,0 +1,101 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.datasketches.memory.internal;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertTrue;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.concurrent.ThreadLocalRandom;
+
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.WritableMemory;
+import org.testng.annotations.Test;
+
+import jdk.incubator.foreign.ResourceScope;
+
+public class MemoryWriteToTest {
+ private final MemoryRequestServer memReqSvr = new DefaultMemoryRequestServer();
+
+ @Test
+ public void testOnHeapBytes() throws IOException {
+ testWriteTo(createRandomBytesMemory(0));
+ testWriteTo(createRandomBytesMemory(7));
+ testWriteTo(createRandomBytesMemory(1023));
+ testWriteTo(createRandomBytesMemory(10_000));
+ testWriteTo(createRandomBytesMemory((1 << 20) * 5));
+ testWriteTo(createRandomBytesMemory(((1 << 20) * 5) + 10));
+ }
+
+ @Test
+ public void testOnHeapInts() throws IOException {
+ testWriteTo(createRandomIntsMemory(0));
+ testWriteTo(createRandomIntsMemory(7));
+ testWriteTo(createRandomIntsMemory(1023));
+ testWriteTo(createRandomIntsMemory(10_000));
+ testWriteTo(createRandomIntsMemory((1 << 20) * 5));
+ testWriteTo(createRandomIntsMemory(((1 << 20) * 5) + 10));
+ }
+
+ @Test
+ public void testOffHeap() throws Exception {
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory mem = WritableMemory.allocateDirect(((1 << 20) * 5) + 10, scope, memReqSvr);
+ testWriteTo(mem.region(0, 0));
+ testOffHeap(mem, 7);
+ testOffHeap(mem, 1023);
+ testOffHeap(mem, 10_000);
+ testOffHeap(mem, (1 << 20) * 5);
+ testOffHeap(mem, ((1 << 20) * 5) + 10);
+ }
+ }
+
+ private static void testOffHeap(WritableMemory mem, int size) throws IOException {
+ createRandomBytesMemory(size).copyTo(0, mem, 0, size);
+ testWriteTo(mem.region(0, size));
+ }
+
+ private static Memory createRandomBytesMemory(int size) {
+ byte[] bytes = new byte[size];
+ ThreadLocalRandom.current().nextBytes(bytes);
+ return Memory.wrap(bytes);
+ }
+
+ private static Memory createRandomIntsMemory(int size) {
+ int[] ints = ThreadLocalRandom.current().ints(size).toArray();
+ return Memory.wrap(ints);
+ }
+
+ private static void testWriteTo(Memory mem) throws IOException {
+ int cap = (int)mem.getCapacity();
+ ByteArrayOutputStream baos = new ByteArrayOutputStream(cap);
+ mem.writeToByteStream(0, cap, baos);
+ byte[] result = baos.toByteArray();
+ assertTrue(mem.equalTo(0, Memory.wrap(result), 0, cap));
+ //OR
+ byte[] barr = new byte[cap];
+ mem.getByteArray(0, barr, 0, cap);
+ assertEquals(barr, result);
+ }
+
+}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/MurmurHash3v3Test.java b/src/test/java/org/apache/datasketches/memory/internal/MurmurHash3v3Test.java
new file mode 100644
index 0000000..91b8ec1
--- /dev/null
+++ b/src/test/java/org/apache/datasketches/memory/internal/MurmurHash3v3Test.java
@@ -0,0 +1,404 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.datasketches.memory.internal;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.apache.datasketches.memory.internal.MurmurHash3v3.*;
+import static org.testng.Assert.fail;
+
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.WritableMemory;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import jdk.incubator.foreign.ResourceScope;
+
+/**
+ * Tests the MurmurHash3 against specific, known hash results given known
+ * inputs obtained from the public domain C++ version 150.
+ *
+ * @author Lee Rhodes
+ */
+public class MurmurHash3v3Test {
+ private final MemoryRequestServer memReqSvr = new DefaultMemoryRequestServer();
+
+ @Test
+ public void checkByteArrRemainderGT8() { //byte[], remainder > 8
+ String keyStr = "The quick brown fox jumps over the lazy dog";
+ byte[] key = keyStr.getBytes(UTF_8);
+ long[] result = hash(key, 0);
+ //Should be:
+ long h1 = 0xe34bbc7bbc071b6cL;
+ long h2 = 0x7a433ca9c49a9347L;
+ Assert.assertEquals(result[0], h1);
+ Assert.assertEquals(result[1], h2);
+ }
+
+ @Test
+ public void checkByteArrChange1bit() { //byte[], change one bit
+ String keyStr = "The quick brown fox jumps over the lazy eog";
+ byte[] key = keyStr.getBytes(UTF_8);
+ long[] result = hash(key, 0);
+ //Should be:
+ long h1 = 0x362108102c62d1c9L;
+ long h2 = 0x3285cd100292b305L;
+ Assert.assertEquals(result[0], h1);
+ Assert.assertEquals(result[1], h2);
+ }
+
+ @Test
+ public void checkByteArrRemainderLt8() { //byte[], test a remainder < 8
+ String keyStr = "The quick brown fox jumps over the lazy dogdogdog";
+ byte[] key = keyStr.getBytes(UTF_8);
+ long[] result = hash(key, 0);
+ //Should be;
+ long h1 = 0x9c8205300e612fc4L;
+ long h2 = 0xcbc0af6136aa3df9L;
+ Assert.assertEquals(result[0], h1);
+ Assert.assertEquals(result[1], h2);
+ }
+
+ @Test
+ public void checkByteArrReaminderEQ8() { //byte[], test a remainder = 8
+ String keyStr = "The quick brown fox jumps over the lazy1";
+ byte[] key = keyStr.getBytes(UTF_8);
+ long[] result = hash(key, 0);
+ //Should be:
+ long h1 = 0xe3301a827e5cdfe3L;
+ long h2 = 0xbdbf05f8da0f0392L;
+ Assert.assertEquals(result[0], h1);
+ Assert.assertEquals(result[1], h2);
+
+ }
+
+ /**
+ * This test should have the exact same output as Test4
+ */
+ @Test
+ public void checkLongArrRemainderEQ8() { //long[], test a remainder = 8
+ String keyStr = "The quick brown fox jumps over the lazy1";
+ long[] key = stringToLongs(keyStr);
+ long[] result = hash(key, 0);
+ //Should be:
+ long h1 = 0xe3301a827e5cdfe3L;
+ long h2 = 0xbdbf05f8da0f0392L;
+ Assert.assertEquals(result[0], h1);
+ Assert.assertEquals(result[1], h2);
+
+ }
+
+ /**
+ * This test should have the exact same output as Test4
+ */
+ @Test
+ public void checkIntArrRemainderEQ8() { //int[], test a remainder = 8
+ String keyStr = "The quick brown fox jumps over the lazy1"; //40B
+ int[] key = stringToInts(keyStr);
+ long[] result = hash(key, 0);
+ //Should be:
+ long h1 = 0xe3301a827e5cdfe3L;
+ long h2 = 0xbdbf05f8da0f0392L;
+ Assert.assertEquals(result[0], h1);
+ Assert.assertEquals(result[1], h2);
+ }
+
+ @Test
+ public void checkIntArrRemainderEQ0() { //int[], test a remainder = 0
+ String keyStr = "The quick brown fox jumps over t"; //32B
+ int[] key = stringToInts(keyStr);
+ long[] result = hash(key, 0);
+ //Should be:
+ long h1 = 0xdf6af91bb29bdacfL;
+ long h2 = 0x91a341c58df1f3a6L;
+ Assert.assertEquals(result[0], h1);
+ Assert.assertEquals(result[1], h2);
+ }
+
+
+ /**
+ * Tests an odd remainder of int[].
+ */
+ @Test
+ public void checkIntArrOddRemainder() { //int[], odd remainder
+ String keyStr = "The quick brown fox jumps over the lazy dog"; //43B
+ int[] key = stringToInts(keyStr);
+ long[] result = hash(key, 0);
+ //Should be:
+ long h1 = 0x1eb232b0087543f5L;
+ long h2 = 0xfc4c1383c3ace40fL;
+ Assert.assertEquals(result[0], h1);
+ Assert.assertEquals(result[1], h2);
+ }
+
+
+ /**
+ * Tests an odd remainder of int[].
+ */
+ @Test
+ public void checkCharArrOddRemainder() { //char[], odd remainder
+ String keyStr = "The quick brown fox jumps over the lazy dog.."; //45B
+ char[] key = keyStr.toCharArray();
+ long[] result = hash(key, 0);
+ //Should be:
+ long h1 = 0xca77b498ea9ed953L;
+ long h2 = 0x8b8f8ec3a8f4657eL;
+ Assert.assertEquals(result[0], h1);
+ Assert.assertEquals(result[1], h2);
+ }
+
+ /**
+ * Tests an odd remainder of int[].
+ */
+ @Test
+ public void checkCharArrRemainderEQ0() { //char[], remainder of 0
+ String keyStr = "The quick brown fox jumps over the lazy "; //40B
+ char[] key = keyStr.toCharArray();
+ long[] result = hash(key, 0);
+ //Should be:
+ long h1 = 0x51b15e9d0887f9f1L;
+ long h2 = 0x8106d226786511ebL;
+ Assert.assertEquals(result[0], h1);
+ Assert.assertEquals(result[1], h2);
+ }
+
+ @Test
+ public void checkByteArrAllOnesZeros() { //byte[], test a ones byte and a zeros byte
+ byte[] key = {
+ 0x54, 0x68, 0x65, 0x20, 0x71, 0x75, 0x69, 0x63, 0x6b, 0x20, 0x62, 0x72, 0x6f, 0x77, 0x6e,
+ 0x20, 0x66, 0x6f, 0x78, 0x20, 0x6a, 0x75, 0x6d, 0x70, 0x73, 0x20, 0x6f, 0x76, 0x65,
+ 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x7a, 0x79, 0x20, 0x64, 0x6f, 0x67,
+ (byte) 0xff, 0x64, 0x6f, 0x67, 0x00
+ };
+ long[] result = MurmurHash3v3.hash(key, 0);
+
+ //Should be:
+ long h1 = 0xe88abda785929c9eL;
+ long h2 = 0x96b98587cacc83d6L;
+ Assert.assertEquals(result[0], h1);
+ Assert.assertEquals(result[1], h2);
+ }
+
+ /**
+ * This test demonstrates that the hash of byte[], char[], int[], or long[] will produce the
+ * same hash result if, and only if, all the arrays have the same exact length in bytes, and if
+ * the contents of the values in the arrays have the same byte endianness and overall order.
+ */
+ @Test
+ public void checkCrossTypeHashConsistency() {
+ long[] out;
+ println("Bytes");
+ byte[] bArr = {1,2,3,4,5,6,7,8, 9,10,11,12,13,14,15,16, 17,18,19,20,21,22,23,24};
+ long[] out1 = hash(bArr, 0L);
+ println(longToHexBytes(out1[0]));
+ println(longToHexBytes(out1[1]));
+
+ println("Chars");
+ char[] cArr = {0X0201, 0X0403, 0X0605, 0X0807, 0X0a09, 0X0c0b, 0X0e0d, 0X100f,
+ 0X1211, 0X1413, 0X1615, 0X1817};
+ out = hash(cArr, 0L);
+ Assert.assertEquals(out, out1);
+ println(longToHexBytes(out[0]));
+ println(longToHexBytes(out[1]));
+
+ println("Ints");
+ int[] iArr = {0X04030201, 0X08070605, 0X0c0b0a09, 0X100f0e0d, 0X14131211, 0X18171615};
+ out = hash(iArr, 0L);
+ Assert.assertEquals(out, out1);
+ println(longToHexBytes(out[0]));
+ println(longToHexBytes(out[1]));
+
+ println("Longs");
+ long[] lArr = {0X0807060504030201L, 0X100f0e0d0c0b0a09L, 0X1817161514131211L};
+ out = hash(lArr, 0L);
+ Assert.assertEquals(out, out1);
+ println(longToHexBytes(out[0]));
+ println(longToHexBytes(out[1]));
+ }
+
+ @Test
+ public void checkEmptyOrNullExceptions() {
+ try {
+ long[] arr = null; hash(arr, 1L); fail();
+ } catch (final IllegalArgumentException e) { }
+ try {
+ int[] arr = null; hash(arr, 1L); fail();
+ } catch (final IllegalArgumentException e) { }
+ try {
+ char[] arr = null; hash(arr, 1L); fail();
+ } catch (final IllegalArgumentException e) { }
+ try {
+ byte[] arr = null; hash(arr, 1L); fail();
+ } catch (final IllegalArgumentException e) { }
+ try {
+ long[] out = new long[2];
+ String in = null; hash(in, 1L, out); fail();
+ } catch (final IllegalArgumentException e) { }
+ try {
+ long[] out = new long[2];
+ Memory mem = Memory.wrap(new byte[0]);
+ out = hash(mem, 0L, 4L, 1L, out);
+ } catch (final IllegalArgumentException e) { }
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ Memory mem = WritableMemory.allocateDirect(8, scope, memReqSvr);
+ long[] out = new long[2];
+ out = hash(mem, 0L, 4L, 1L, out);
+ } catch (Exception ee) {}
+ }
+
+ @Test
+ public void checkHashTails() {
+ long[] out = new long[2];
+ WritableMemory mem = WritableMemory.allocate(32);
+ mem.fill((byte)85);
+
+ for (int i = 16; i <= 32; i++) {
+ out = hash(mem, 0, i, 1L, out);
+ }
+ }
+
+ @Test
+ public void checkSinglePrimitives() {
+ long[] out = new long[2];
+ out = hash(1L, 1L, out);
+ out = hash(0.0, 1L, out);
+ out = hash("123", 1L, out);
+ }
+
+ //Helper methods
+
+ private static long[] stringToLongs(String in) {
+ byte[] bArr = in.getBytes(UTF_8);
+ int inLen = bArr.length;
+ int outLen = (inLen / 8) + (((inLen % 8) != 0) ? 1 : 0);
+ long[] out = new long[outLen];
+
+ for (int i = 0; i < (outLen - 1); i++ ) {
+ for (int j = 0; j < 8; j++ ) {
+ out[i] |= ((bArr[(i * 8) + j] & 0xFFL) << (j * 8));
+ }
+ }
+ int inTail = 8 * (outLen - 1);
+ int rem = inLen - inTail;
+ for (int j = 0; j < rem; j++ ) {
+ out[outLen - 1] |= ((bArr[inTail + j] & 0xFFL) << (j * 8));
+ }
+ return out;
+ }
+
+ private static int[] stringToInts(String in) {
+ byte[] bArr = in.getBytes(UTF_8);
+ int inLen = bArr.length;
+ int outLen = (inLen / 4) + (((inLen % 4) != 0) ? 1 : 0);
+ int[] out = new int[outLen];
+
+ for (int i = 0; i < (outLen - 1); i++ ) {
+ for (int j = 0; j < 4; j++ ) {
+ out[i] |= ((bArr[(i * 4) + j] & 0xFFL) << (j * 8));
+ }
+ }
+ int inTail = 4 * (outLen - 1);
+ int rem = inLen - inTail;
+ for (int j = 0; j < rem; j++ ) {
+ out[outLen - 1] |= ((bArr[inTail + j] & 0xFFL) << (j * 8));
+ }
+ return out;
+ }
+
+ /**
+ * Returns a string of spaced hex bytes in Big-Endian order.
+ * @param v the given long
+ * @return string of spaced hex bytes in Big-Endian order.
+ */
+ private static String longToHexBytes(final long v) {
+ final long mask = 0XFFL;
+ final StringBuilder sb = new StringBuilder();
+ for (int i = 8; i-- > 0; ) {
+ final String s = Long.toHexString((v >>> (i * 8)) & mask);
+ sb.append(zeroPad(s, 2)).append(" ");
+ }
+ return sb.toString();
+ }
+
+ /**
+ * Prepend the given string with zeros. If the given string is equal or greater than the given
+ * field length, it will be returned without modification.
+ * @param s the given string
+ * @param fieldLength desired total field length including the given string
+ * @return the given string prepended with zeros.
+ */
+ private static final String zeroPad(final String s, final int fieldLength) {
+ return characterPad(s, fieldLength, '0', false);
+ }
+
+ /**
+ * Prepend or postpend the given string with the given character to fill the given field length.
+ * If the given string is equal or greater than the given field length, it will be returned
+ * without modification.
+ * @param s the given string
+ * @param fieldLength the desired field length
+ * @param padChar the desired pad character
+ * @param postpend if true append the padCharacters to the end of the string.
+ * @return prepended or postpended given string with the given character to fill the given field
+ * length.
+ */
+ private static final String characterPad(final String s, final int fieldLength, final char padChar,
+ final boolean postpend) {
+ final char[] chArr = s.toCharArray();
+ final int sLen = chArr.length;
+ if (sLen < fieldLength) {
+ final char[] out = new char[fieldLength];
+ final int blanks = fieldLength - sLen;
+
+ if (postpend) {
+ for (int i = 0; i < sLen; i++) {
+ out[i] = chArr[i];
+ }
+ for (int i = sLen; i < fieldLength; i++) {
+ out[i] = padChar;
+ }
+ } else { //prepend
+ for (int i = 0; i < blanks; i++) {
+ out[i] = padChar;
+ }
+ for (int i = blanks; i < fieldLength; i++) {
+ out[i] = chArr[i - blanks];
+ }
+ }
+
+ return String.valueOf(out);
+ }
+ return s;
+ }
+
+ @Test
+ public void printlnTest() {
+ println("PRINTING: "+this.getClass().getName());
+ }
+
+ /**
+ * @param s value to print
+ */
+ static void println(String s) {
+ //System.out.println(s); //disable here
+ }
+
+}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/NativeWritableBufferImplTest.java b/src/test/java/org/apache/datasketches/memory/internal/NativeWritableBufferImplTest.java
new file mode 100644
index 0000000..dcca8b7
--- /dev/null
+++ b/src/test/java/org/apache/datasketches/memory/internal/NativeWritableBufferImplTest.java
@@ -0,0 +1,569 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.datasketches.memory.internal;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertFalse;
+import static org.testng.Assert.assertNotNull;
+import static org.testng.Assert.assertTrue;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+import org.apache.datasketches.memory.BaseState;
+import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.ReadOnlyException;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import jdk.incubator.foreign.ResourceScope;
+
+public class NativeWritableBufferImplTest {
+ private final MemoryRequestServer memReqSvr = new DefaultMemoryRequestServer();
+
+ //Simple Native direct
+
+ @SuppressWarnings("resource")
+ @Test
+ public void checkNativeCapacityAndClose() throws Exception {
+ int memCapacity = 64;
+ ResourceScope scope = ResourceScope.newConfinedScope();
+ WritableMemory wmem = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+ WritableBuffer wbuf = wmem.asWritableBuffer();
+ assertEquals(wbuf.getCapacity(), memCapacity);
+
+ wmem.close(); //intentional
+ assertFalse(wbuf.isAlive());
+ wmem.close(); //intentional, nothing to free
+ }
+
+ //Simple Heap arrays
+
+ @Test
+ public void checkByteArray() {
+ byte[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
+ byte[] dstArray = new byte[8];
+
+ Buffer buf = Memory.wrap(srcArray).asBuffer();
+ buf.getByteArray(dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+
+ WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ wbuf.getByteArray(dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+ }
+
+ @Test
+ public void checkCharArray() {
+ char[] srcArray = { 1, 2, 3, 4, 5, 6, 7, 8 };
+ char[] dstArray = new char[8];
+
+ Buffer buf = Memory.wrap(srcArray).asBuffer();
+ buf.getCharArray(dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+
+ WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ wbuf.getCharArray(dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+ }
+
+ @Test
+ public void checkShortArray() {
+ short[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
+ short[] dstArray = new short[8];
+
+ Buffer buf = Memory.wrap(srcArray).asBuffer();
+ buf.getShortArray(dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+
+ WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ wbuf.getShortArray(dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+ }
+
+ @Test
+ public void checkIntArray() {
+ int[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
+ int[] dstArray = new int[8];
+
+ Buffer buf = Memory.wrap(srcArray).asBuffer();
+ buf.getIntArray(dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+
+ WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ wbuf.getIntArray(dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+ }
+
+ @Test
+ public void checkLongArray() {
+ long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
+ long[] dstArray = new long[8];
+
+ Buffer buf = Memory.wrap(srcArray).asBuffer();
+ buf.getLongArray(dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+
+ WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ wbuf.getLongArray(dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+ }
+
+ @Test
+ public void checkFloatArray() {
+ float[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
+ float[] dstArray = new float[8];
+
+ Buffer buf = Memory.wrap(srcArray).asBuffer();
+ buf.getFloatArray(dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+
+ WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ wbuf.getFloatArray(dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+ }
+
+ @Test
+ public void checkDoubleArray() {
+ double[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
+ double[] dstArray = new double[8];
+
+ Buffer buf = Memory.wrap(srcArray).asBuffer();
+ buf.getDoubleArray(dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+
+ WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ wbuf.getDoubleArray(dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+ }
+
+ @Test
+ public void checkNativeBaseBound() throws Exception {
+ int memCapacity = 64;
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory wmem = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+ WritableBuffer wbuf = wmem.asWritableBuffer();
+ wbuf.toHexString("Force Assertion Error", memCapacity, 8, false);
+ } catch (IllegalArgumentException e) {
+ //ok
+ }
+ }
+
+ @Test
+ public void checkNativeSrcArrayBound() throws Exception {
+ long memCapacity = 64;
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory wmem = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+ WritableBuffer wbuf = wmem.asWritableBuffer();
+ byte[] srcArray = { 1, -2, 3, -4 };
+ wbuf.putByteArray(srcArray, 0, 5); //wrong!
+ } catch (IndexOutOfBoundsException e) {
+ //pass
+ }
+ }
+
+ @Test(expectedExceptions = IndexOutOfBoundsException.class)
+ public void checkRegionBounds() throws Exception {
+ int memCapacity = 64;
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory wmem = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+ WritableBuffer wbuf = wmem.asWritableBuffer();
+ wbuf.writableRegion(1, 64, wbuf.getTypeByteOrder()); //wrong!
+ }
+ }
+
+ @Test
+ public void checkByteBufferWrap() {
+ int memCapacity = 64;
+ ByteBuffer byteBuf = ByteBuffer.allocate(memCapacity);
+ byteBuf.order(ByteOrder.nativeOrder());
+
+ for (int i=0; i<memCapacity; i++) {
+ byteBuf.put(i, (byte) i);
+ }
+
+ WritableBuffer wbuf = WritableBuffer.writableWrap(byteBuf);
+
+ for (int i=0; i<memCapacity; i++) {
+ assertEquals(wbuf.getByte(), byteBuf.get(i));
+ }
+
+ assertTrue(wbuf.hasByteBuffer());
+ ByteBuffer byteBuf2 = wbuf.toByteBuffer(ByteOrder.nativeOrder());
+ assertEquals(byteBuf2, byteBuf);
+ //println( mem.toHexString("HeapBB", 0, memCapacity));
+ }
+
+ @Test
+ public void checkWrapWithBBReadonly1() {
+ int memCapacity = 64;
+ ByteBuffer byteBuf = ByteBuffer.allocate(memCapacity);
+ byteBuf.order(ByteOrder.nativeOrder());
+
+ for (int i = 0; i < memCapacity; i++) {
+ byteBuf.put(i, (byte) i);
+ }
+
+ Buffer buf = WritableBuffer.writableWrap(byteBuf);
+
+ for (int i = 0; i < memCapacity; i++) {
+ assertEquals(buf.getByte(), byteBuf.get(i));
+ }
+
+ //println(mem.toHexString("HeapBB", 0, memCapacity));
+ }
+
+ @Test(expectedExceptions = ReadOnlyException.class)
+ public void checkWrapWithBBReadonly2() {
+ int memCapacity = 64;
+ ByteBuffer byteBuf = ByteBuffer.allocate(memCapacity);
+ byteBuf.order(ByteOrder.nativeOrder());
+ ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
+ byteBufRO.order(ByteOrder.nativeOrder());
+ assertTrue(true);
+ WritableBuffer wbuf = WritableBuffer.writableWrap(byteBufRO);
+ assertTrue(wbuf.isReadOnly());
+ }
+
+ @Test
+ public void checkWrapWithDirectBBReadonly() {
+ int memCapacity = 64;
+ ByteBuffer byteBuf = ByteBuffer.allocateDirect(memCapacity);
+ byteBuf.order(ByteOrder.nativeOrder());
+
+ for (int i = 0; i < memCapacity; i++) {
+ byteBuf.put(i, (byte) i);
+ }
+ ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
+ byteBufRO.order(ByteOrder.nativeOrder());
+
+ Buffer buf = Buffer.wrap(byteBufRO);
+
+ for (int i = 0; i < memCapacity; i++) {
+ assertEquals(buf.getByte(), byteBuf.get(i));
+ }
+
+ //println(mem.toHexString("HeapBB", 0, memCapacity));
+ }
+
+ @Test(expectedExceptions = ReadOnlyException.class)
+ public void checkWrapWithDirectBBReadonlyPut() {
+ int memCapacity = 64;
+ ByteBuffer byteBuf = ByteBuffer.allocateDirect(memCapacity);
+ ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
+ byteBufRO.order(ByteOrder.nativeOrder());
+
+ WritableBuffer.writableWrap(byteBufRO);
+ }
+
+ @Test
+ public void checkByteBufferWrapDirectAccess() {
+ int memCapacity = 64;
+ ByteBuffer byteBuf = ByteBuffer.allocateDirect(memCapacity);
+ byteBuf.order(ByteOrder.nativeOrder());
+
+ for (int i=0; i<memCapacity; i++) {
+ byteBuf.put(i, (byte) i);
+ }
+
+ Buffer buf = Buffer.wrap(byteBuf);
+
+ for (int i=0; i<memCapacity; i++) {
+ assertEquals(buf.getByte(), byteBuf.get(i));
+ }
+
+ //println( mem.toHexString("HeapBB", 0, memCapacity));
+ }
+
+ @SuppressWarnings("resource")
+ @Test
+ public void checkIsDirect() throws Exception {
+ int memCapacity = 64;
+ WritableBuffer mem = WritableMemory.allocate(memCapacity).asWritableBuffer();
+ assertFalse(mem.isDirect());
+ ResourceScope scope = ResourceScope.newConfinedScope();
+ WritableMemory wmem = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+ WritableBuffer wbuf = wmem.asWritableBuffer();
+ assertTrue(wbuf.isDirect());
+ wmem.close(); //immediate close
+ }
+
+ @Test
+ public void checkIsReadOnly() {
+ long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
+
+ WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ assertFalse(wbuf.isReadOnly());
+
+ Buffer buf = wbuf;
+ assertFalse(buf.isReadOnly());
+
+ for (int i = 0; i < srcArray.length; i++) {
+ assertEquals(buf.getLong(), srcArray[i]);
+ }
+ }
+
+ @Test
+ public void checkGoodBounds() {
+ BaseStateImpl.checkBounds(50, 50, 100);
+ }
+
+ @Test
+ public void checkCompareToHeap() {
+ 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};
+
+ 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);
+ comp = buf1.compareTo(0, 4, buf2, 0, 4);
+ assertEquals(comp, -1);
+ comp = buf2.compareTo(0, 4, buf1, 0, 4);
+ assertEquals(comp, 1);
+ //different lengths
+ comp = buf1.compareTo(0, 4, buf3, 0, 5);
+ assertEquals(comp, -1);
+ comp = buf3.compareTo(0, 5, buf1, 0, 4);
+ assertEquals(comp, 1);
+ }
+
+ @Test
+ 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 (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory mem1 = WritableMemory.allocateDirect(4, scope, memReqSvr);
+ WritableMemory mem2 = WritableMemory.allocateDirect(4, scope, memReqSvr);
+ WritableMemory mem3 = WritableMemory.allocateDirect(5, scope, memReqSvr);
+
+ mem1.putByteArray(0, arr1, 0, 4);
+ mem2.putByteArray(0, arr2, 0, 4);
+ mem3.putByteArray(0, arr3, 0, 5);
+
+ Buffer buf1 = mem1.asBuffer();
+ Buffer buf2 = mem2.asBuffer();
+ Buffer buf3 = mem3.asBuffer();
+
+ int comp = buf1.compareTo(0, 3, buf2, 0, 3);
+ assertEquals(comp, 0);
+ comp = buf1.compareTo(0, 4, buf2, 0, 4);
+ assertEquals(comp, -1);
+ comp = buf2.compareTo(0, 4, buf1, 0, 4);
+ assertEquals(comp, 1);
+ //different lengths
+ comp = buf1.compareTo(0, 4, buf3, 0, 5);
+ assertEquals(comp, -1);
+ comp = buf3.compareTo(0, 5, buf1, 0, 4);
+ assertEquals(comp, 1);
+ }
+ }
+
+ @Test
+ public void checkAsBuffer() {
+ 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()));
+
+ Buffer buf = wmem.asBuffer();
+ buf.setPosition(32);
+ for (int i = 32; i < 64; i++) {
+ assertEquals(buf.getByte(), i);
+ }
+ }
+
+ @Test
+ public void checkDuplicate() {
+ WritableMemory wmem = WritableMemory.allocate(64);
+ for (int i = 0; i < 64; i++) { wmem.putByte(i, (byte)i); }
+
+ WritableBuffer wbuf = wmem.asWritableBuffer().writableDuplicate();
+
+ for (int i = 0; i < 64; i++) {
+ assertEquals(wbuf.getByte(), i);
+ }
+ Buffer buf = wmem.asBuffer().duplicate();
+ for (int i = 0; i < 64; i++) {
+ assertEquals(buf.getByte(), i);
+ }
+
+ WritableMemory wmem2 = wbuf.asWritableMemory();
+ for (int i = 0; i < 64; i++) {
+ assertEquals(wmem2.getByte(i), i);
+ }
+ wbuf.asWritableMemory();
+
+ }
+
+ @Test
+ public void checkIsSameResource() {
+ byte[] byteArr = new byte[64];
+ WritableBuffer wbuf1 = WritableMemory.writableWrap(byteArr).asWritableBuffer();
+ WritableBuffer wbuf2 = WritableMemory.writableWrap(byteArr).asWritableBuffer();
+ assertTrue(wbuf1.isSameResource(wbuf2));
+ }
+
+ @Test
+ public void checkDegenerateRegionReturn() {
+ 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);
+ WritableBuffer wbuf = WritableBuffer.writableWrap(bb);
+ WritableMemory wmem = wbuf.asWritableMemory(); //OK
+ assertNotNull(wmem);
+
+ try {
+ Buffer buf = Buffer.wrap(bb.asReadOnlyBuffer());
+ wbuf = (WritableBuffer) buf;
+ wmem = wbuf.asWritableMemory();
+ Assert.fail();
+ } catch (ReadOnlyException expected) {
+ // expected
+ }
+ }
+
+ @Test
+ public void checkWritableDuplicateRO() {
+ ByteBuffer bb = ByteBuffer.allocate(64);
+ WritableBuffer wbuf = WritableBuffer.writableWrap(bb);
+ @SuppressWarnings("unused")
+ WritableBuffer wdup = wbuf.writableDuplicate();
+
+ try {
+ Buffer buf = Buffer.wrap(bb);
+ wbuf = (WritableBuffer) buf;
+ @SuppressWarnings("unused")
+ WritableBuffer wdup2 = wbuf.writableDuplicate();
+ Assert.fail();
+ } catch (ReadOnlyException expected) {
+ // ignore
+ }
+ }
+
+ @Test
+ public void checkWritableRegionRO() {
+ ByteBuffer bb = ByteBuffer.allocate(64);
+ WritableBuffer wbuf = WritableBuffer.writableWrap(bb);
+ @SuppressWarnings("unused")
+ WritableBuffer wreg = wbuf.writableRegion();
+
+ try {
+ Buffer buf = Buffer.wrap(bb);
+ wbuf = (WritableBuffer) buf;
+ @SuppressWarnings("unused")
+ WritableBuffer wreg2 = wbuf.writableRegion();
+ Assert.fail();
+ } catch (ReadOnlyException expected) {
+ // ignore
+ }
+ }
+
+ @Test
+ public void checkWritableRegionWithParamsRO() {
+ ByteBuffer bb = ByteBuffer.allocate(64);
+ WritableBuffer wbuf = WritableBuffer.writableWrap(bb);
+ @SuppressWarnings("unused")
+ WritableBuffer wreg = wbuf.writableRegion(0, 1, wbuf.getTypeByteOrder());
+
+ try {
+ Buffer buf = Buffer.wrap(bb);
+ wbuf = (WritableBuffer) buf;
+ @SuppressWarnings("unused")
+ WritableBuffer wreg2 = wbuf.writableRegion(0, 1, wbuf.getTypeByteOrder());
+ Assert.fail();
+ } catch (ReadOnlyException expected) {
+ // ignore
+ }
+ }
+
+ @Test
+ public void checkZeroBuffer() {
+ 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() {
+ WritableMemory wmem = WritableMemory.allocate(64);
+ wmem.putShort(0, (short) 1);
+ Buffer buf = wmem.asWritableBuffer().duplicate(BaseState.NON_NATIVE_BYTE_ORDER);
+ assertEquals(buf.getShort(0), 256);
+ }
+
+ @Test
+ public void printlnTest() {
+ println("PRINTING: "+this.getClass().getName());
+ }
+
+ /**
+ * @param s value to print
+ */
+ static void println(String s) {
+ //System.out.println(s); //disable here
+ }
+
+}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/NativeWritableMemoryImplTest.java b/src/test/java/org/apache/datasketches/memory/internal/NativeWritableMemoryImplTest.java
new file mode 100644
index 0000000..9dd98f1
--- /dev/null
+++ b/src/test/java/org/apache/datasketches/memory/internal/NativeWritableMemoryImplTest.java
@@ -0,0 +1,689 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.datasketches.memory.internal;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertFalse;
+import static org.testng.Assert.assertTrue;
+import static org.testng.Assert.fail;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+import org.apache.datasketches.memory.BaseState;
+import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.ReadOnlyException;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
+import org.testng.annotations.Test;
+
+import jdk.incubator.foreign.ResourceScope;
+
+public class NativeWritableMemoryImplTest {
+ private final MemoryRequestServer memReqSvr = new DefaultMemoryRequestServer();
+
+ //Simple Native direct
+
+ @SuppressWarnings("resource")
+ @Test
+ public void checkNativeCapacityAndClose() throws Exception {
+ int memCapacity = 64;
+ ResourceScope scope = ResourceScope.newConfinedScope();
+ WritableMemory wmem = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+ assertEquals(memCapacity, wmem.getCapacity());
+
+ wmem.close(); //intentional
+ assertFalse(wmem.isAlive());
+
+ wmem.close(); //intentional, nothing to free
+ }
+
+ //Simple Native arrays
+
+ @Test
+ public void checkByteArray() {
+ byte[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
+ byte[] dstArray = new byte[8];
+
+ Memory mem = Memory.wrap(srcArray);
+ mem.getByteArray(0, dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ wmem.getByteArray(0, dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+ }
+
+ @Test
+ public void checkCharArray() {
+ char[] srcArray = { 1, 2, 3, 4, 5, 6, 7, 8 };
+ char[] dstArray = new char[8];
+
+ Memory mem = Memory.wrap(srcArray);
+ mem.getCharArray(0, dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ wmem.getCharArray(0, dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+ }
+
+ @Test
+ public void checkShortArray() {
+ short[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
+ short[] dstArray = new short[8];
+
+ Memory mem = Memory.wrap(srcArray);
+ mem.getShortArray(0, dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ wmem.getShortArray(0, dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+ }
+
+ @Test
+ public void checkIntArray() {
+ int[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
+ int[] dstArray = new int[8];
+
+ Memory mem = Memory.wrap(srcArray);
+ mem.getIntArray(0, dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ wmem.getIntArray(0, dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+ }
+
+ @Test
+ public void checkLongArray() {
+ long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
+ long[] dstArray = new long[8];
+
+ Memory mem = Memory.wrap(srcArray);
+ mem.getLongArray(0, dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ wmem.getLongArray(0, dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+ }
+
+ @Test
+ public void checkFloatArray() {
+ float[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
+ float[] dstArray = new float[8];
+
+ Memory mem = Memory.wrap(srcArray);
+ mem.getFloatArray(0, dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ wmem.getFloatArray(0, dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+ }
+
+ @Test
+ public void checkDoubleArray() {
+ double[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
+ double[] dstArray = new double[8];
+
+ Memory mem = Memory.wrap(srcArray);
+ mem.getDoubleArray(0, dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ wmem.getDoubleArray(0, dstArray, 0, 8);
+ for (int i=0; i<8; i++) {
+ assertEquals(dstArray[i], srcArray[i]);
+ }
+ }
+
+ @Test
+ public void checkNativeBaseBound() throws Exception {
+ int memCapacity = 64;
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory wmem = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+ wmem.toHexString("Force Assertion Error", memCapacity, 8, false);
+ } catch (IllegalArgumentException e) {
+ //ok
+ }
+ }
+
+ @Test
+ public void checkNativeSrcArrayBound() throws Exception {
+ long memCapacity = 64;
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory wmem = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+ byte[] srcArray = { 1, -2, 3, -4 };
+ wmem.putByteArray(0L, srcArray, 0, 5);
+ } catch (IndexOutOfBoundsException e) {
+ //pass
+ }
+ }
+
+ //Copy Within tests
+
+ @Test
+ public void checkDegenerateCopyTo() {
+ WritableMemory wmem = WritableMemory.allocate(64);
+ wmem.copyTo(0, wmem, 0, 64);
+ }
+
+ @Test
+ public void checkCopyWithinNativeSmall() throws Exception {
+ int memCapacity = 64;
+ int half = memCapacity/2;
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory wmem = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+ wmem.clear();
+
+ for (int i=0; i<half; i++) { //fill first half
+ wmem.putByte(i, (byte) i);
+ }
+
+ wmem.copyTo(0, wmem, half, half);
+
+ for (int i=0; i<half; i++) {
+ assertEquals(wmem.getByte(i+half), (byte) i);
+ }
+ }
+ }
+
+ @Test
+ public void checkCopyWithinNativeLarge() throws Exception {
+ int memCapacity = (2 << 20) + 64;
+ int memCapLongs = memCapacity / 8;
+ int halfBytes = memCapacity / 2;
+ int halfLongs = memCapLongs / 2;
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory wmem = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+ wmem.clear();
+
+ for (int i=0; i < halfLongs; i++) {
+ wmem.putLong(i*8, i);
+ }
+
+ wmem.copyTo(0, wmem, halfBytes, halfBytes);
+
+ for (int i=0; i < halfLongs; i++) {
+ assertEquals(wmem.getLong((i + halfLongs)*8), i);
+ }
+ }
+ }
+
+ @Test
+ public void checkCopyWithinNativeSrcBound() throws Exception {
+ int memCapacity = 64;
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory wmem = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+ wmem.copyTo(32, wmem, 32, 33); //hit source bound check
+ fail("Did Not Catch Assertion Error: source bound");
+ }
+ catch (IndexOutOfBoundsException e) {
+ //pass
+ }
+ }
+
+ @Test
+ public void checkCopyWithinNativeDstBound() throws Exception {
+ int memCapacity = 64;
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory wmem = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+ wmem.copyTo(0, wmem, 32, 33); //hit dst bound check
+ fail("Did Not Catch Assertion Error: dst bound");
+ }
+ catch (IndexOutOfBoundsException e) {
+ //pass
+ }
+ }
+
+ @Test
+ public void checkCopyCrossNativeSmall() throws Exception {
+ int memCapacity = 64;
+
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory wmem1 = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+ WritableMemory wmem2 = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+
+ for (int i=0; i < memCapacity; i++) {
+ wmem1.putByte(i, (byte) i);
+ }
+ wmem2.clear();
+ wmem1.copyTo(0, wmem2, 0, memCapacity);
+
+ for (int i=0; i<memCapacity; i++) {
+ assertEquals(wmem2.getByte(i), (byte) i);
+ }
+ }
+ }
+
+ @Test
+ public void checkCopyCrossNativeLarge() throws Exception {
+ int memCapacity = (2<<20) + 64;
+ int memCapLongs = memCapacity / 8;
+
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory wmem1 = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+ WritableMemory wmem2 = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+
+ for (int i=0; i < memCapLongs; i++) {
+ wmem1.putLong(i*8, i);
+ }
+ wmem2.clear();
+
+ wmem1.copyTo(0, wmem2, 0, memCapacity);
+
+ for (int i=0; i<memCapLongs; i++) {
+ assertEquals(wmem2.getLong(i*8), i);
+ }
+ }
+ }
+
+ @Test
+ public void checkCopyCrossNativeAndByteArray() throws Exception {
+ int memCapacity = 64;
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory wmem = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+
+ for (int i= 0; i < wmem.getCapacity(); i++) {
+ wmem.putByte(i, (byte) i);
+ }
+
+ WritableMemory wmem2 = WritableMemory.allocate(memCapacity);
+ wmem.copyTo(8, wmem2, 16, 16);
+
+ for (int i=0; i<16; i++) {
+ assertEquals(wmem.getByte(8+i), wmem2.getByte(16+i));
+ }
+ //println(mem2.toHexString("Mem2", 0, (int)mem2.getCapacity()));
+ }
+ }
+
+ @Test
+ public void checkCopyCrossRegionsSameNative() throws Exception {
+ int memCapacity = 128;
+
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory wmem1 = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+
+ for (int i= 0; i < wmem1.getCapacity(); i++) {
+ wmem1.putByte(i, (byte) i);
+ }
+ //println(mem1.toHexString("Mem1", 0, (int)mem1.getCapacity()));
+
+ Memory reg1 = wmem1.region(8, 16);
+ //println(reg1.toHexString("Reg1", 0, (int)reg1.getCapacity()));
+
+ WritableMemory reg2 = wmem1.writableRegion(24, 16);
+ //println(reg2.toHexString("Reg2", 0, (int)reg2.getCapacity()));
+ reg1.copyTo(0, reg2, 0, 16);
+
+ for (int i=0; i<16; i++) {
+ assertEquals(reg1.getByte(i), reg2.getByte(i));
+ assertEquals(wmem1.getByte(8+i), wmem1.getByte(24+i));
+ }
+ //println(mem1.toHexString("Mem1", 0, (int)mem1.getCapacity()));
+ }
+ }
+
+ @Test
+ public void checkCopyCrossNativeArrayAndHierarchicalRegions() throws Exception {
+ int memCapacity = 64;
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory wmem1 = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+
+ for (int i= 0; i < wmem1.getCapacity(); i++) { //fill with numbers
+ wmem1.putByte(i, (byte) i);
+ }
+ //println(mem1.toHexString("Mem1", 0, (int)mem1.getCapacity()));
+
+ WritableMemory wmem2 = WritableMemory.allocate(memCapacity);
+
+ Memory reg1 = wmem1.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()));
+
+ WritableMemory reg2 = wmem2.writableRegion(32, 16);
+ reg1B.copyTo(0, reg2, 0, 16);
+ //println(reg2.toHexString("Reg2", 0, (int)reg2.getCapacity()));
+
+ //println(mem2.toHexString("Mem2", 0, (int)mem2.getCapacity()));
+ for (int i = 32, j = 16; i < 40; i++, j++) {
+ assertEquals(wmem2.getByte(i), j);
+ }
+ }
+
+ }
+
+ @Test(expectedExceptions = IndexOutOfBoundsException.class)
+ public void checkRegionBounds() throws Exception {
+ int memCapacity = 64;
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory wmem = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+ wmem.writableRegion(1, 64);
+ }
+ }
+
+ @Test
+ public void checkByteBufferWrap() {
+ int memCapacity = 64;
+ ByteBuffer byteBuf = ByteBuffer.allocate(memCapacity);
+ byteBuf.order(ByteOrder.nativeOrder());
+
+ for (int i=0; i<memCapacity; i++) {
+ byteBuf.put(i, (byte) i);
+ }
+
+ WritableMemory wmem = WritableMemory.writableWrap(byteBuf);
+
+ for (int i=0; i<memCapacity; i++) {
+ assertEquals(wmem.getByte(i), byteBuf.get(i));
+ }
+
+ assertTrue(wmem.hasByteBuffer());
+ ByteBuffer byteBuf2 = wmem.toByteBuffer(ByteOrder.nativeOrder());
+ assertEquals(byteBuf2, byteBuf);
+ //println( mem.toHexString("HeapBB", 0, memCapacity));
+ }
+
+ @Test
+ public void checkWrapWithBBReadonly1() {
+ int memCapacity = 64;
+ ByteBuffer byteBuf = ByteBuffer.allocate(memCapacity);
+ byteBuf.order(ByteOrder.nativeOrder());
+
+ for (int i = 0; i < memCapacity; i++) {
+ byteBuf.put(i, (byte) i);
+ }
+
+ Memory mem = WritableMemory.writableWrap(byteBuf);
+
+ for (int i = 0; i < memCapacity; i++) {
+ assertEquals(mem.getByte(i), byteBuf.get(i));
+ }
+
+ //println(mem.toHexString("HeapBB", 0, memCapacity));
+ }
+
+ @Test(expectedExceptions = ReadOnlyException.class)
+ public void checkWrapWithBBReadonly2() {
+ int memCapacity = 64;
+ ByteBuffer byteBuf = ByteBuffer.allocate(memCapacity);
+ byteBuf.order(ByteOrder.nativeOrder());
+ ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
+
+ WritableMemory.writableWrap(byteBufRO);
+ }
+
+ @Test
+ public void checkWrapWithDirectBBReadonly() {
+ int memCapacity = 64;
+ ByteBuffer byteBuf = ByteBuffer.allocateDirect(memCapacity);
+ byteBuf.order(ByteOrder.nativeOrder());
+
+ for (int i = 0; i < memCapacity; i++) {
+ byteBuf.put(i, (byte) i);
+ }
+ ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
+ byteBufRO.order(ByteOrder.nativeOrder());
+
+ Memory mem = Memory.wrap(byteBufRO);
+
+ for (int i = 0; i < memCapacity; i++) {
+ assertEquals(mem.getByte(i), byteBuf.get(i));
+ }
+
+ //println(mem.toHexString("HeapBB", 0, memCapacity));
+ }
+
+ @Test(expectedExceptions = ReadOnlyException.class)
+ public void checkWrapWithDirectBBReadonlyPut() {
+ int memCapacity = 64;
+ ByteBuffer byteBuf = ByteBuffer.allocateDirect(memCapacity);
+ ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
+ byteBufRO.order(ByteOrder.nativeOrder());
+
+ WritableMemory.writableWrap(byteBufRO);
+ }
+
+ @Test
+ public void checkByteBufferWrapDirectAccess() {
+ int memCapacity = 64;
+ ByteBuffer byteBuf = ByteBuffer.allocateDirect(memCapacity);
+ byteBuf.order(ByteOrder.nativeOrder());
+
+ for (int i=0; i<memCapacity; i++) {
+ byteBuf.put(i, (byte) i);
+ }
+
+ Memory mem = Memory.wrap(byteBuf);
+
+ for (int i=0; i<memCapacity; i++) {
+ assertEquals(mem.getByte(i), byteBuf.get(i));
+ }
+
+ //println( mem.toHexString("HeapBB", 0, memCapacity));
+ }
+
+ @Test
+ public void checkIsDirect() throws Exception {
+ int memCapacity = 64;
+ WritableMemory mem = WritableMemory.allocate(memCapacity);
+ assertFalse(mem.isDirect());
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory wmem = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+ assertTrue(wmem.isDirect());
+ }
+ }
+
+ @Test
+ public void checkIsReadOnly() {
+ long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
+
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ assertFalse(wmem.isReadOnly());
+
+ Memory memRO = wmem;
+ assertFalse(memRO.isReadOnly());
+
+ for (int i = 0; i < wmem.getCapacity(); i++) {
+ assertEquals(wmem.getByte(i), memRO.getByte(i));
+ }
+ }
+
+ @Test
+ public void checkGoodBounds() {
+ BaseStateImpl.checkBounds(50, 50, 100);
+ }
+
+ @Test
+ public void checkCompareToHeap() {
+ 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};
+
+ 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);
+ comp = mem1.compareTo(0, 4, mem2, 0, 4);
+ assertEquals(comp, -1);
+ comp = mem2.compareTo(0, 4, mem1, 0, 4);
+ assertEquals(comp, 1);
+ //different lengths
+ comp = mem1.compareTo(0, 4, mem3, 0, 5);
+ assertEquals(comp, -1);
+ comp = mem3.compareTo(0, 5, mem1, 0, 4);
+ assertEquals(comp, 1);
+ comp = mem3.compareTo(0, 5, mem4, 0, 5);
+ assertEquals(comp, 0);
+ comp = mem3.compareTo(0, 4, mem4, 1, 4);
+ assertEquals(comp, -1);
+ BaseStateImpl.checkBounds(0, 5, mem3.getCapacity());
+ }
+
+ @Test
+ 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 (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory mem1 = WritableMemory.allocateDirect(4, scope, memReqSvr);
+ WritableMemory mem2 = WritableMemory.allocateDirect(4, scope, memReqSvr);
+ WritableMemory mem3 = WritableMemory.allocateDirect(5, scope, memReqSvr);
+
+ mem1.putByteArray(0, arr1, 0, 4);
+ mem2.putByteArray(0, arr2, 0, 4);
+ mem3.putByteArray(0, arr3, 0, 5);
+
+ int comp = mem1.compareTo(0, 3, mem2, 0, 3);
+ assertEquals(comp, 0);
+ comp = mem1.compareTo(0, 4, mem2, 0, 4);
+ assertEquals(comp, -1);
+ comp = mem2.compareTo(0, 4, mem1, 0, 4);
+ assertEquals(comp, 1);
+ //different lengths
+ comp = mem1.compareTo(0, 4, mem3, 0, 5);
+ assertEquals(comp, -1);
+ comp = mem3.compareTo(0, 5, mem1, 0, 4);
+ assertEquals(comp, 1);
+ }
+ }
+
+ @Test
+ public void testCompareToSameStart() {
+ 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));
+ }
+
+ @Test
+ public void checkAsBuffer() {
+ 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()));
+
+ Buffer buf = wmem.asBuffer();
+ buf.setPosition(32);
+ for (int i = 32; i < 64; i++) {
+ assertEquals(buf.getByte(), i);
+ }
+ }
+
+ @Test
+ public void checkIsSameResource() {
+ byte[] byteArr = new byte[64];
+ WritableMemory wmem1 = WritableMemory.writableWrap(byteArr);
+ WritableMemory wmem2 = WritableMemory.writableWrap(byteArr);
+ assertTrue(wmem1.isSameResource(wmem2));
+ }
+
+ @Test
+ public void checkAsWritableBufferWithBB() {
+ ByteBuffer byteBuf = ByteBuffer.allocate(64);
+ byteBuf.position(16);
+ byteBuf.limit(48);
+ WritableMemory wmem = WritableMemory.writableWrap(byteBuf);
+ WritableBuffer wbuf = wmem.asWritableBuffer();
+ assertEquals(wbuf.getCapacity(), 64);
+ assertEquals(wbuf.getPosition(), 0);
+ assertEquals(wbuf.getEnd(), 64);
+ }
+
+ @Test(expectedExceptions = ReadOnlyException.class)
+ public void checkAsWritableRegionRO() {
+ ByteBuffer byteBuf = ByteBuffer.allocate(64);
+ WritableMemory wmem = (WritableMemory) Memory.wrap(byteBuf);
+ wmem.writableRegion(0, 1);
+ }
+
+ @Test(expectedExceptions = ReadOnlyException.class)
+ public void checkAsWritableBufferRO() {
+ ByteBuffer byteBuf = ByteBuffer.allocate(64);
+ WritableMemory wmem = (WritableMemory) Memory.wrap(byteBuf);
+ wmem.asWritableBuffer();
+ }
+
+ @Test void checkZeroMemory() {
+ WritableMemory wmem = WritableMemory.allocate(8);
+ WritableMemory reg = wmem.writableRegion(0, 0);
+ assertEquals(reg.getCapacity(), 0);
+ }
+
+ @Test
+ public void checkAsBufferNonNative() {
+ WritableMemory wmem = WritableMemory.allocate(64);
+ wmem.putShort(0, (short) 1);
+ Buffer buf = wmem.asBuffer(BaseState.NON_NATIVE_BYTE_ORDER);
+ assertEquals(buf.getShort(0), 256);
+ }
+
+ @Test
+ public void printlnTest() {
+ println("PRINTING: "+this.getClass().getName());
+ }
+
+ /**
+ * @param s value to print
+ */
+ static void println(String s) {
+ //System.out.println(s); //disable here
+ }
+
+}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/NonNativeWritableBufferImplTest.java b/src/test/java/org/apache/datasketches/memory/internal/NonNativeWritableBufferImplTest.java
new file mode 100644
index 0000000..155409b
--- /dev/null
+++ b/src/test/java/org/apache/datasketches/memory/internal/NonNativeWritableBufferImplTest.java
@@ -0,0 +1,279 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.datasketches.memory.internal;
+
+import static org.testng.Assert.assertEquals;
+
+import java.nio.ByteOrder;
+
+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;
+
+/**
+ * @author Lee Rhodes
+ */
+public class NonNativeWritableBufferImplTest {
+
+//Check primitives
+ @Test
+ public void checkCharacters() {
+ int n = 8;
+ int m = Character.BYTES;
+ byte[] arr1 = new byte[n * m]; //non-native
+ //put & get
+ 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';
+ for (int i = 0; i < n; i++) {
+ assertEquals(wbuf.getChar(i * m), ch++);
+ }
+ ch = 'a';
+ wbuf.setPosition(0);
+ for (int i = 0; i < n; i++) { wbuf.putChar(ch++); }
+ ch = 'a';
+ wbuf.setPosition(0);
+ for (int i = 0; i < n; i++) {
+ assertEquals(wbuf.getChar(), ch++);
+ }
+ //getArr & putArr
+ char[] cArr = new char[n]; //native
+ wbuf.setPosition(0);
+ wbuf.getCharArray(cArr, 0, n); //wmem is non-native
+ byte[] arr2 = new byte[n * m];
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableBuffer wbuf2 = wmem2.asWritableBuffer();
+ wbuf2.putCharArray(cArr, 0, n);
+ assertEquals(arr2, arr1);
+ }
+
+ @Test
+ public void checkDoubles() {
+ int n = 8;
+ int m = Double.BYTES;
+ byte[] arr1 = new byte[n * m]; //non-native
+ //put & get
+ 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;
+ for (int i = 0; i < n; i++) {
+ assertEquals(wbuf.getDouble(i * m), dbl++);
+ }
+ dbl = 1.0;
+ wbuf.setPosition(0);
+ for (int i = 0; i < n; i++) { wbuf.putDouble(dbl++); }
+ dbl = 1.0;
+ wbuf.setPosition(0);
+ for (int i = 0; i < n; i++) {
+ assertEquals(wbuf.getDouble(), dbl++);
+ }
+ //getArr & putArr
+ double[] dblArr = new double[n]; //native
+ wbuf.setPosition(0);
+ wbuf.getDoubleArray(dblArr, 0, n); //wmem is non-native
+ byte[] arr2 = new byte[n * m];
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableBuffer wbuf2 = wmem2.asWritableBuffer();
+ wbuf2.putDoubleArray(dblArr, 0, n);
+ assertEquals(arr2, arr1);
+ }
+
+ @Test
+ public void checkFloats() {
+ int n = 8;
+ int m = Float.BYTES;
+ byte[] arr1 = new byte[n * m]; //non-native
+ //put & get
+ 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;
+ for (int i = 0; i < n; i++) {
+ assertEquals(wbuf.getFloat(i * m), flt++);
+ }
+ flt = 1.0F;
+ wbuf.setPosition(0);
+ for (int i = 0; i < n; i++) { wbuf.putFloat(flt++); }
+ flt = 1.0F;
+ wbuf.setPosition(0);
+ for (int i = 0; i < n; i++) {
+ assertEquals(wbuf.getFloat(), flt++);
+ }
+ //getArr & putArr
+ float[] fltArr = new float[n]; //native
+ wbuf.setPosition(0);
+ wbuf.getFloatArray(fltArr, 0, n); //wmem is non-native
+ byte[] arr2 = new byte[n * m];
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableBuffer wbuf2 = wmem2.asWritableBuffer();
+ wbuf2.putFloatArray(fltArr, 0, n);
+ assertEquals(arr2, arr1);
+ }
+
+ @Test
+ public void checkInts() {
+ int n = 8;
+ int m = Integer.BYTES;
+ byte[] arr1 = new byte[n * m]; //non-native
+ //put & get
+ 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;
+ for (int i = 0; i < n; i++) {
+ assertEquals(wbuf.getInt(i * m), intg++);
+ }
+ intg = 1;
+ wbuf.setPosition(0);
+ for (int i = 0; i < n; i++) { wbuf.putInt(intg++); }
+ intg = 1;
+ wbuf.setPosition(0);
+ for (int i = 0; i < n; i++) {
+ assertEquals(wbuf.getInt(), intg++);
+ }
+ //getArr & putArr
+ int[] intArr = new int[n]; //native
+ wbuf.setPosition(0);
+ wbuf.getIntArray(intArr, 0, n); //wmem is non-native
+ byte[] arr2 = new byte[n * m];
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableBuffer wbuf2 = wmem2.asWritableBuffer();
+ wbuf2.putIntArray(intArr, 0, n);
+ assertEquals(arr2, arr1);
+ }
+
+ @Test
+ public void checkLongs() {
+ int n = 8;
+ int m = Long.BYTES;
+ byte[] arr1 = new byte[n * m]; //non-native
+ //put & get
+ 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;
+ for (int i = 0; i < n; i++) {
+ assertEquals(wbuf.getLong(i * m), lng++);
+ }
+ lng = 1;
+ wbuf.setPosition(0);
+ for (int i = 0; i < n; i++) { wbuf.putLong(lng++); }
+ lng = 1;
+ wbuf.setPosition(0);
+ for (int i = 0; i < n; i++) {
+ assertEquals(wbuf.getLong(), lng++);
+ }
+ //getArr & putArr
+ long[] longArr = new long[n]; //native
+ wbuf.setPosition(0);
+ wbuf.getLongArray(longArr, 0, n); //wmem is non-native
+ byte[] arr2 = new byte[n * m];
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableBuffer wbuf2 = wmem2.asWritableBuffer();
+ wbuf2.putLongArray(longArr, 0, n);
+ assertEquals(arr2, arr1);
+ }
+
+ @Test
+ public void checkShorts() {
+ int n = 8;
+ int m = Short.BYTES;
+ byte[] arr1 = new byte[n * m]; //non-native
+ //put & get
+ 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;
+ for (int i = 0; i < n; i++) {
+ assertEquals(wbuf.getShort(i * m), sht++);
+ }
+ sht = 1;
+ wbuf.setPosition(0);
+ for (int i = 0; i < n; i++) { wbuf.putShort(sht++); }
+ sht = 1;
+ wbuf.setPosition(0);
+ for (int i = 0; i < n; i++) {
+ assertEquals(wbuf.getShort(), sht++);
+ }
+ //getArr & putArr
+ short[] shortArr = new short[n]; //native
+ wbuf.setPosition(0);
+ wbuf.getShortArray(shortArr, 0, n); //wmem is non-native
+ byte[] arr2 = new byte[n * m];
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableBuffer wbuf2 = wmem2.asWritableBuffer();
+ wbuf2.putShortArray(shortArr, 0, n);
+ assertEquals(arr2, arr1);
+ }
+
+ //check Duplicate, Region
+ @Test
+ public void checkDuplicate() {
+ byte[] bArr = new byte[8];
+ WritableMemory wmem = WritableMemory.writableWrap(bArr, ByteOrder.BIG_ENDIAN);
+ WritableBuffer wbuf = wmem.asWritableBuffer();
+ WritableBuffer wdup = wbuf.writableDuplicate();
+ assertEquals(wdup.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
+
+ WritableBuffer wreg = wbuf.writableRegion();
+ assertEquals(wreg.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
+ }
+
+ @Test
+ public void checkConversionByteOrder() {
+ byte[] bArr = new byte[8];
+ bArr[1] = 1;
+ WritableMemory wmem = WritableMemory.writableWrap(bArr, ByteOrder.BIG_ENDIAN);
+ assertEquals(wmem.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
+ assertEquals(wmem.getChar(0), 1);
+
+ Buffer buf = wmem.asBuffer();
+ assertEquals(buf.getTypeByteOrder(), ByteOrder.BIG_ENDIAN); //
+ assertEquals(buf.getChar(0), 1);
+
+ Buffer dup = buf.duplicate();
+ assertEquals(dup.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
+ assertEquals(dup.getChar(0), 1);
+
+ Buffer reg = buf.region();
+ assertEquals(reg.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
+ assertEquals(reg.getChar(0), 1);
+
+ Memory mem = reg.asMemory();
+ assertEquals(mem.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
+ assertEquals(mem.getChar(0), 1);
+
+ Memory mreg = mem.region(0, 8);
+ assertEquals(mreg.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
+ assertEquals(mreg.getChar(0), 1);
+
+ }
+
+}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/NonNativeWritableMemoryImplTest.java b/src/test/java/org/apache/datasketches/memory/internal/NonNativeWritableMemoryImplTest.java
new file mode 100644
index 0000000..fcfff82
--- /dev/null
+++ b/src/test/java/org/apache/datasketches/memory/internal/NonNativeWritableMemoryImplTest.java
@@ -0,0 +1,176 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.datasketches.memory.internal;
+
+import static org.testng.Assert.assertEquals;
+
+import java.nio.ByteOrder;
+
+import org.apache.datasketches.memory.WritableMemory;
+import org.testng.annotations.Test;
+
+/**
+ * @author Lee Rhodes
+ */
+public class NonNativeWritableMemoryImplTest {
+ private byte[] bArr = new byte[8];
+ private final WritableMemory wmem = WritableMemory.writableWrap(bArr, ByteOrder.BIG_ENDIAN);
+
+//Check primitives
+ @Test
+ public void checkCharacters() {
+ int m = Character.BYTES;
+ int n = ((1 << 20) / m) + m;
+ byte[] arr1 = new byte[n * m]; //non-native
+ //put & get
+ 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++);
+ }
+ //getArr & putArr
+ char[] cArr = new char[n]; //native
+ wmem1.getCharArray(0, cArr, 0, n); //wmem is non-native
+ byte[] arr2 = new byte[n * m];
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ wmem2.putCharArray(0, cArr, 0, n);
+ assertEquals(arr2, arr1);
+ }
+
+ @Test
+ public void checkDoubles() {
+ int m = Double.BYTES;
+ int n = ((1 << 20) / m) + m;
+ byte[] arr1 = new byte[n * m]; //non-native
+ //put & get
+ 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;
+ for (int i = 0; i < n; i++) {
+ assertEquals(wmem1.getDouble(i * m), dbl++);
+ }
+ //getArr & putArr
+ double[] dblArr = new double[n]; //native
+ wmem1.getDoubleArray(0, dblArr, 0, n); //wmem is non-native
+ byte[] arr2 = new byte[n * m];
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ wmem2.putDoubleArray(0, dblArr, 0, n);
+ assertEquals(arr2, arr1);
+ }
+
+ @Test
+ public void checkFloats() {
+ int m = Float.BYTES;
+ int n = ((1 << 20) / m) + m;
+ byte[] arr1 = new byte[n * m]; //non-native
+ //put & get
+ 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;
+ for (int i = 0; i < n; i++) {
+ assertEquals(wmem1.getFloat(i * m), flt++);
+ }
+ //getArr & putArr
+ float[] fltArr = new float[n]; //native
+ wmem1.getFloatArray(0, fltArr, 0, n); //wmem is non-native
+ byte[] arr2 = new byte[n * m];
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ wmem2.putFloatArray(0, fltArr, 0, n);
+ assertEquals(arr2, arr1);
+ }
+
+ @Test
+ public void checkInts() {
+ int m = Integer.BYTES;
+ int n = ((1 << 20) / m) + m;
+ byte[] arr1 = new byte[n * m]; //non-native
+ //put & get
+ 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;
+ for (int i = 0; i < n; i++) {
+ assertEquals(wmem1.getInt(i * m), intg++);
+ }
+ //getArr & putArr
+ int[] intArr = new int[n]; //native
+ wmem1.getIntArray(0, intArr, 0, n); //wmem is non-native
+ byte[] arr2 = new byte[n * m];
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ wmem2.putIntArray(0, intArr, 0, n);
+ assertEquals(arr2, arr1);
+ }
+
+ @Test
+ public void checkLongs() {
+ int m = Long.BYTES;
+ int n = ((1 << 20) / m) + m;
+ byte[] arr1 = new byte[n * m]; //non-native
+ //put & get
+ 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;
+ for (int i = 0; i < n; i++) {
+ assertEquals(wmem1.getLong(i * m), lng++);
+ }
+ //getArr & putArr
+ long[] longArr = new long[n]; //native
+ wmem1.getLongArray(0, longArr, 0, n); //wmem is non-native
+ byte[] arr2 = new byte[n * m];
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ wmem2.putLongArray(0, longArr, 0, n);
+ assertEquals(arr2, arr1);
+ }
+
+ @Test
+ public void checkShorts() {
+ int m = Short.BYTES;
+ int n = ((1 << 20) / m) + m;
+ byte[] arr1 = new byte[n * m]; //non-native
+ //put & get
+ 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;
+ for (int i = 0; i < n; i++) {
+ assertEquals(wmem1.getShort(i * m), sht++);
+ }
+ //getArr & putArr
+ short[] shortArr = new short[n]; //native
+ wmem1.getShortArray(0, shortArr, 0, n); //wmem is non-native
+ byte[] arr2 = new byte[n * m];
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ wmem2.putShortArray(0, shortArr, 0, n);
+ assertEquals(arr2, arr1);
+ }
+
+ //check Atomic Write Methods
+
+ //check Region
+ @Test
+ public void checkRegion() {
+ WritableMemory wreg = wmem.writableRegion(0, wmem.getCapacity());
+ assertEquals(wreg.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
+ }
+
+}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/SpecificLeafTest.java b/src/test/java/org/apache/datasketches/memory/internal/SpecificLeafTest.java
new file mode 100644
index 0000000..07fdbdb
--- /dev/null
+++ b/src/test/java/org/apache/datasketches/memory/internal/SpecificLeafTest.java
@@ -0,0 +1,197 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.datasketches.memory.internal;
+
+import static org.testng.Assert.assertFalse;
+import static org.testng.Assert.assertTrue;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+import org.apache.datasketches.memory.BaseState;
+import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.WritableMemory;
+import org.testng.annotations.Test;
+
+import jdk.incubator.foreign.ResourceScope;
+
+/**
+ * @author Lee Rhodes
+ */
+public class SpecificLeafTest {
+ private final MemoryRequestServer memReqSvr = new DefaultMemoryRequestServer();
+
+ @Test
+ public void checkByteBufferLeafs() {
+ int bytes = 128;
+ ByteBuffer bb = ByteBuffer.allocate(bytes);
+ bb.order(ByteOrder.nativeOrder());
+
+ Memory mem = Memory.wrap(bb).region(0, bytes, ByteOrder.nativeOrder());
+ assertTrue(mem.hasByteBuffer());
+ assertTrue(mem.isReadOnly());
+ checkCrossLeafTypeIds(mem);
+ Buffer buf = mem.asBuffer().region(0, bytes, ByteOrder.nativeOrder());
+
+ bb.order(BaseState.NON_NATIVE_BYTE_ORDER);
+ Memory mem2 = Memory.wrap(bb).region(0, bytes, BaseState.NON_NATIVE_BYTE_ORDER);
+ Buffer buf2 = mem2.asBuffer().region(0, bytes, BaseState.NON_NATIVE_BYTE_ORDER);
+ Buffer buf3 = buf2.duplicate();
+
+ assertTrue(((BaseStateImpl)mem).isRegionType());
+ assertTrue(((BaseStateImpl)mem2).isRegionType());
+ assertTrue(((BaseStateImpl)buf).isRegionType());
+ assertTrue(((BaseStateImpl)buf2).isRegionType());
+ assertTrue(((BaseStateImpl)buf3).isDuplicateType());
+ }
+
+ @Test
+ public void checkDirectLeafs() throws Exception {
+ int bytes = 128;
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory wmem = WritableMemory.allocateDirect(bytes, scope, memReqSvr);
+ assertTrue(((BaseStateImpl)wmem).isDirectType());
+ assertFalse(wmem.isReadOnly());
+ checkCrossLeafTypeIds(wmem);
+ WritableMemory nnwmem = wmem.writableRegion(0, bytes, BaseState.NON_NATIVE_BYTE_ORDER);
+
+ Memory mem = wmem.region(0, bytes, ByteOrder.nativeOrder());
+ Buffer buf = mem.asBuffer().region(0, bytes, ByteOrder.nativeOrder());
+
+
+ Memory mem2 = nnwmem.region(0, bytes, BaseState.NON_NATIVE_BYTE_ORDER);
+ Buffer buf2 = mem2.asBuffer().region(0, bytes, BaseState.NON_NATIVE_BYTE_ORDER);
+ Buffer buf3 = buf2.duplicate();
+
+ assertTrue(((BaseStateImpl)mem).isRegionType());
+ assertTrue(((BaseStateImpl)mem2).isRegionType());
+ assertTrue(((BaseStateImpl)buf).isRegionType());
+ assertTrue(((BaseStateImpl)buf2).isRegionType());
+ assertTrue(((BaseStateImpl)buf3).isDuplicateType());
+ }
+ }
+
+ @Test
+ public void checkMapLeafs() throws Exception {
+ File file = new File("TestFile2.bin");
+ if (file.exists()) {
+ try {
+ java.nio.file.Files.delete(file.toPath());
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ assertTrue(file.createNewFile());
+ assertTrue(file.setWritable(true, false)); //writable=true, ownerOnly=false
+ assertTrue(file.isFile());
+ file.deleteOnExit(); //comment out if you want to examine the file.
+
+ final long bytes = 128;
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory mem = WritableMemory.writableMap(file, 0L, bytes, scope, ByteOrder.nativeOrder());
+ assertTrue(((BaseStateImpl)mem).isMapType());
+ assertFalse(mem.isReadOnly());
+ checkCrossLeafTypeIds(mem);
+ Memory nnreg = mem.region(0, bytes, BaseState.NON_NATIVE_BYTE_ORDER);
+
+ Memory reg = mem.region(0, bytes, ByteOrder.nativeOrder());
+ Buffer buf = reg.asBuffer().region(0, bytes, ByteOrder.nativeOrder());
+ Buffer buf4 = buf.duplicate();
+
+ Memory reg2 = nnreg.region(0, bytes, BaseState.NON_NATIVE_BYTE_ORDER);
+ Buffer buf2 = reg2.asBuffer().region(0, bytes, BaseState.NON_NATIVE_BYTE_ORDER);
+ Buffer buf3 = buf2.duplicate();
+
+ assertTrue(((BaseStateImpl)reg).isRegionType());
+ assertTrue(((BaseStateImpl)reg2).isRegionType());
+ assertTrue(((BaseStateImpl)buf).isRegionType());
+ assertTrue(((BaseStateImpl)buf2).isRegionType());
+ assertTrue(((BaseStateImpl)buf3).isDuplicateType());
+ assertTrue(((BaseStateImpl)buf4).isDuplicateType());
+ }
+ }
+
+ @Test
+ public void checkHeapLeafs() {
+ int bytes = 128;
+ Memory mem = Memory.wrap(new byte[bytes]);
+ assertTrue(((BaseStateImpl)mem).isHeapType());
+ assertTrue(((BaseStateImpl)mem).isReadOnly());
+ checkCrossLeafTypeIds(mem);
+ Memory nnreg = mem.region(0, bytes, BaseState.NON_NATIVE_BYTE_ORDER);
+
+ Memory reg = mem.region(0, bytes, ByteOrder.nativeOrder());
+ Buffer buf = reg.asBuffer().region(0, bytes, ByteOrder.nativeOrder());
+ Buffer buf4 = buf.duplicate();
+
+ Memory reg2 = nnreg.region(0, bytes, BaseState.NON_NATIVE_BYTE_ORDER);
+ Buffer buf2 = reg2.asBuffer().region(0, bytes, BaseState.NON_NATIVE_BYTE_ORDER);
+ Buffer buf3 = buf2.duplicate();
+
+ assertFalse(((BaseStateImpl)mem).isRegionType());
+ assertTrue(((BaseStateImpl)reg2).isRegionType());
+ assertTrue(((BaseStateImpl)buf).isRegionType());
+ assertTrue(((BaseStateImpl)buf2).isRegionType());
+ assertTrue(((BaseStateImpl)buf3).isDuplicateType());
+ assertTrue(((BaseStateImpl)buf4).isDuplicateType());
+ }
+
+ private static void checkCrossLeafTypeIds(Memory mem) {
+ Memory reg1 = mem.region(0, mem.getCapacity());
+ assertTrue(((BaseStateImpl)reg1).isRegionType());
+
+ Buffer buf1 = reg1.asBuffer();
+ assertTrue(((BaseStateImpl)buf1).isRegionType()); //fails
+ assertTrue(((BaseStateImpl)buf1).isBufferType());
+ assertTrue(buf1.isReadOnly());
+
+ Buffer buf2 = buf1.duplicate();
+ assertTrue(((BaseStateImpl)buf2).isRegionType());
+ assertTrue(((BaseStateImpl)buf2).isBufferType());
+ assertTrue(((BaseStateImpl)buf2).isDuplicateType());
+ assertTrue(buf2.isReadOnly());
+
+ Memory mem2 = buf1.asMemory(); //
+ assertTrue(((BaseStateImpl)mem2).isRegionType());
+ assertFalse(((BaseStateImpl)mem2).isBufferType());
+ assertFalse(((BaseStateImpl)mem2).isDuplicateType());
+ assertTrue(mem2.isReadOnly());
+
+ Buffer buf3 = buf1.duplicate(BaseState.NON_NATIVE_BYTE_ORDER);
+ assertTrue(((BaseStateImpl)buf3).isRegionType());
+ assertTrue(((BaseStateImpl)buf3).isBufferType());
+ assertTrue(((BaseStateImpl)buf3).isDuplicateType());
+ assertTrue(((BaseStateImpl)buf3).isNonNativeType());
+ assertTrue(buf3.isReadOnly());
+
+ Memory mem3 = buf3.asMemory();
+ assertTrue(((BaseStateImpl)mem3).isRegionType());
+ assertFalse(((BaseStateImpl)mem3).isBufferType());
+ assertTrue(((BaseStateImpl)mem3).isDuplicateType());
+ assertTrue(((BaseStateImpl)mem3).isNonNativeType());
+ assertTrue(mem3.isReadOnly());
+ }
+
+}
diff --git a/src/test/java/org/apache/datasketches/memory/test/UtilTest.java b/src/test/java/org/apache/datasketches/memory/internal/UtilTest.java
similarity index 98%
rename from src/test/java/org/apache/datasketches/memory/test/UtilTest.java
rename to src/test/java/org/apache/datasketches/memory/internal/UtilTest.java
index abe23e4..7752c76 100644
--- a/src/test/java/org/apache/datasketches/memory/test/UtilTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/UtilTest.java
@@ -21,7 +21,7 @@
* Note: Lincoln's Gettysburg Address is in the public domain. See LICENSE.
*/
-package org.apache.datasketches.memory.test;
+package org.apache.datasketches.memory.internal;
import static org.apache.datasketches.memory.internal.Util.characterPad;
import static org.apache.datasketches.memory.internal.Util.getResourceBytes;
@@ -42,7 +42,6 @@ import java.nio.file.attribute.PosixFileAttributeView;
import java.nio.file.attribute.PosixFileAttributes;
import java.nio.file.attribute.PosixFilePermissions;
-import org.apache.datasketches.memory.internal.Util;
import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
diff --git a/src/test/java/org/apache/datasketches/memory/internal/WritableDirectCopyTest.java b/src/test/java/org/apache/datasketches/memory/internal/WritableDirectCopyTest.java
new file mode 100644
index 0000000..2fda457
--- /dev/null
+++ b/src/test/java/org/apache/datasketches/memory/internal/WritableDirectCopyTest.java
@@ -0,0 +1,253 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.datasketches.memory.internal;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.fail;
+
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.WritableMemory;
+import org.testng.annotations.Test;
+
+import jdk.incubator.foreign.ResourceScope;
+
+/**
+ * @author Lee Rhodes
+ */
+public class WritableDirectCopyTest {
+ private final MemoryRequestServer memReqSvr = new DefaultMemoryRequestServer();
+
+//Copy Within tests
+
+ @Test
+ public void checkCopyWithinNativeSmall() throws Exception {
+ int memCapacity = 64;
+ int half = memCapacity / 2;
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory mem = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+ mem.clear();
+
+ for (int i = 0; i < half; i++) { //fill first half
+ mem.putByte(i, (byte) i);
+ }
+
+ mem.copyTo(0, mem, half, half);
+
+ for (int i = 0; i < half; i++) {
+ assertEquals(mem.getByte(i + half), (byte) i);
+ }
+ }
+ }
+
+ @Test
+ public void checkCopyWithinNativeLarge() throws Exception {
+ int memCapacity = (2 << 20) + 64;
+ int memCapLongs = memCapacity / 8;
+ int halfBytes = memCapacity / 2;
+ int halfLongs = memCapLongs / 2;
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory mem = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+ mem.clear();
+
+ for (int i = 0; i < halfLongs; i++) {
+ mem.putLong(i * 8, i);
+ }
+
+ mem.copyTo(0, mem, halfBytes, halfBytes);
+
+ for (int i = 0; i < halfLongs; i++) {
+ assertEquals(mem.getLong((i + halfLongs) * 8), i);
+ }
+ }
+ }
+
+ @Test
+ public void checkCopyWithinNativeOverlap() throws Exception {
+ int memCapacity = 64;
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory mem = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+ mem.clear();
+ //println(mem.toHexString("Clear 64", 0, memCapacity));
+
+ for (int i = 0; i < (memCapacity / 2); i++) {
+ mem.putByte(i, (byte) i);
+ }
+ //println(mem.toHexString("Set 1st 32 to ints ", 0, memCapacity));
+ mem.copyTo(0, mem, memCapacity / 4, memCapacity / 2); //overlap is OK
+ }
+ }
+
+ @Test
+ public void checkCopyWithinNativeSrcBound() throws Exception {
+ int memCapacity = 64;
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory mem = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+ mem.copyTo(32, mem, 32, 33); //hit source bound check
+ fail("Did Not Catch Assertion Error: source bound");
+ } catch (IndexOutOfBoundsException e) {
+ //pass
+ }
+ }
+
+ @Test
+ public void checkCopyWithinNativeDstBound() throws Exception {
+ int memCapacity = 64;
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory mem = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+ mem.copyTo(0, mem, 32, 33); //hit dst bound check
+ fail("Did Not Catch Assertion Error: dst bound");
+ } catch (IndexOutOfBoundsException e) {
+ //pass
+ }
+ }
+
+ @Test
+ public void checkCopyCrossNativeSmall() throws Exception {
+ int memCapacity = 64;
+
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory mem1 = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+ WritableMemory mem2 = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+
+ for (int i = 0; i < memCapacity; i++) {
+ mem1.putByte(i, (byte) i);
+ }
+ mem2.clear();
+ mem1.copyTo(0, mem2, 0, memCapacity);
+
+ for (int i = 0; i < memCapacity; i++) {
+ assertEquals(mem2.getByte(i), (byte) i);
+ }
+ }
+ }
+
+ @Test
+ public void checkCopyCrossNativeLarge() throws Exception {
+ int memCapacity = (2 << 20) + 64;
+ int memCapLongs = memCapacity / 8;
+
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory mem1 = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+ WritableMemory mem2 = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+
+ for (int i = 0; i < memCapLongs; i++) {
+ mem1.putLong(i * 8, i);
+ }
+ mem2.clear();
+
+ mem1.copyTo(0, mem2, 0, memCapacity);
+
+ for (int i = 0; i < memCapLongs; i++) {
+ assertEquals(mem2.getLong(i * 8), i);
+ }
+ }
+ }
+
+ @Test
+ public void checkCopyCrossNativeAndByteArray() throws Exception {
+ int memCapacity = 64;
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory mem1 = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+
+ for (int i = 0; i < mem1.getCapacity(); i++) {
+ mem1.putByte(i, (byte) i);
+ }
+
+ WritableMemory mem2 = WritableMemory.allocate(memCapacity);
+ mem1.copyTo(8, mem2, 16, 16);
+
+ for (int i = 0; i < 16; i++) {
+ assertEquals(mem1.getByte(8 + i), mem2.getByte(16 + i));
+ }
+ //println(mem2.toHexString("Mem2", 0, (int)mem2.getCapacity()));
+ }
+ }
+
+ @Test
+ public void checkCopyCrossRegionsSameNative() throws Exception {
+ int memCapacity = 128;
+
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory mem1 = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+
+ for (int i = 0; i < mem1.getCapacity(); i++) {
+ mem1.putByte(i, (byte) i);
+ }
+ //println(mem1.toHexString("Mem1", 0, (int)mem1.getCapacity()));
+
+ Memory reg1 = mem1.region(8, 16);
+ //println(reg1.toHexString("Reg1", 0, (int)reg1.getCapacity()));
+
+ WritableMemory reg2 = mem1.writableRegion(24, 16);
+ //println(reg2.toHexString("Reg2", 0, (int)reg2.getCapacity()));
+ reg1.copyTo(0, reg2, 0, 16);
+
+ for (int i = 0; i < 16; i++) {
+ assertEquals(reg1.getByte(i), reg2.getByte(i));
+ assertEquals(mem1.getByte(8 + i), mem1.getByte(24 + i));
+ }
+ //println(mem1.toHexString("Mem1", 0, (int)mem1.getCapacity()));
+ }
+ }
+
+ @Test
+ public void checkCopyCrossNativeArrayAndHierarchicalRegions() throws Exception {
+ int memCapacity = 64;
+ try (ResourceScope scope = ResourceScope.newConfinedScope()) {
+ WritableMemory mem1 = WritableMemory.allocateDirect(memCapacity, scope, memReqSvr);
+
+ for (int i = 0; i < mem1.getCapacity(); i++) { //fill with numbers
+ mem1.putByte(i, (byte) i);
+ }
+ //println(mem1.toHexString("Mem1", 0, (int)mem1.getCapacity()));
+
+ WritableMemory mem2 = WritableMemory.allocate(memCapacity);
+
+ 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()));
+
+ WritableMemory reg2 = mem2.writableRegion(32, 16);
+ reg1B.copyTo(0, reg2, 0, 16);
+ //println(reg2.toHexString("Reg2", 0, (int)reg2.getCapacity()));
+
+ //println(mem2.toHexString("Mem2", 0, (int)mem2.getCapacity()));
+ for (int i = 32, j = 16; i < 40; i++, j++) {
+ assertEquals(mem2.getByte(i), j);
+ }
+ }
+ }
+
+ @Test
+ public void printlnTest() {
+ println("PRINTING: " + this.getClass().getName());
+ }
+
+ /**
+ * @param s value to print
+ */
+ static void println(String s) {
+ //System.out.println(s); //disable here
+ }
+
+}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/WritableMemoryTest.java b/src/test/java/org/apache/datasketches/memory/internal/WritableMemoryTest.java
new file mode 100644
index 0000000..ee104fa
--- /dev/null
+++ b/src/test/java/org/apache/datasketches/memory/internal/WritableMemoryTest.java
@@ -0,0 +1,183 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.datasketches.memory.internal;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertFalse;
+import static org.testng.Assert.assertTrue;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.concurrent.ThreadLocalRandom;
+
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.WritableMemory;
+import org.testng.annotations.Test;
+
+public class WritableMemoryTest {
+
+ @Test
+ public void wrapBigEndian() {
+ ByteBuffer bb = ByteBuffer.allocate(64); //big endian
+ WritableMemory wmem = WritableMemory.writableWrap(bb);
+ assertEquals(wmem.getTypeByteOrder(), ByteOrder.LITTLE_ENDIAN); //ignore BB endianness
+ wmem = WritableMemory.writableWrap(bb, ByteOrder.nativeOrder());
+ assertEquals(wmem.getTypeByteOrder(), ByteOrder.LITTLE_ENDIAN);
+ }
+
+ @Test
+ public void wrapBigEndianAsLittle() {
+ ByteBuffer bb = ByteBuffer.allocate(64);
+ bb.putChar(0, (char)1); //as NNO
+ WritableMemory wmem = WritableMemory.writableWrap(bb, ByteOrder.LITTLE_ENDIAN);
+ assertEquals(wmem.getChar(0), 256);
+ }
+
+ @Test
+ public void allocateWithByteOrder() {
+ WritableMemory wmem = WritableMemory.allocate(64, ByteOrder.BIG_ENDIAN);
+ assertEquals(wmem.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
+ wmem = WritableMemory.allocate(64, ByteOrder.LITTLE_ENDIAN);
+ assertEquals(wmem.getTypeByteOrder(), ByteOrder.LITTLE_ENDIAN);
+ wmem = WritableMemory.writableWrap(new byte[64], 32, 32, ByteOrder.BIG_ENDIAN);
+ assertEquals(wmem.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
+ }
+
+ @Test
+ public void checkSelfArrayCopy() {
+ byte[] srcAndDst = new byte[128];
+ WritableMemory wmem = WritableMemory.writableWrap(srcAndDst);
+ wmem.getByteArray(0, srcAndDst, 64, 64); //non-overlapping
+ }
+
+ @Test
+ public void checkEquals() {
+ int len = 7;
+ 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);
+
+ WritableMemory wmem2 = WritableMemory.allocate(len + 1);
+ assertFalse(wmem1.equals(wmem2));
+
+ WritableMemory reg1 = wmem1.writableRegion(0, wmem1.getCapacity());
+ assertTrue(wmem1.equalTo(0, reg1, 0, wmem1.getCapacity()));
+
+ wmem2 = WritableMemory.allocate(len);
+ for (int i = 0; i < len; i++) {
+ wmem1.putByte(i, (byte) i);
+ wmem2.putByte(i, (byte) i);
+ }
+ assertTrue(wmem1.equalTo(0, wmem2, 0, len));
+ assertTrue(wmem1.equalTo(0, wmem1, 0, len));
+
+ reg1 = wmem1.writableRegion(0, wmem1.getCapacity());
+ assertTrue(wmem1.equalTo(0, reg1, 0, len));
+
+ len = 24;
+ 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);
+ }
+ assertTrue(wmem1.equalTo(0, wmem2, 0, len - 1));
+ assertTrue(wmem1.equalTo(0, wmem2, 0, len));
+ wmem2.putByte(0, (byte) 10);
+ assertFalse(wmem1.equalTo(0, wmem2, 0, len));
+ wmem2.putByte(0, (byte) 0);
+ wmem2.putByte(len - 2, (byte) 0);
+ assertFalse(wmem1.equalTo(0, wmem2, 0, len - 1));
+ }
+
+ @Test
+ public void checkEquals2() {
+ int len = 23;
+ WritableMemory wmem1 = WritableMemory.allocate(len);
+ assertFalse(wmem1.equals(null));
+
+ WritableMemory wmem2 = WritableMemory.allocate(len + 1);
+ assertTrue(wmem1.equalTo(0, wmem2, 0, len));
+
+ for (int i = 0; i < len; i++) {
+ wmem1.putByte(i, (byte) i);
+ wmem2.putByte(i, (byte) i);
+ }
+ assertTrue(wmem1.equalTo(0, wmem2, 0, len));
+ assertTrue(wmem1.equalTo(1, wmem2, 1, len - 1));
+ }
+
+ @Test
+ public void checkLargeEquals() {
+ final int thresh = 1 << 20;
+ final int len = thresh * 2 + 7;
+ byte[] byteArr1 = new byte[len];
+ ThreadLocalRandom.current().nextBytes(byteArr1);
+ byte[] byteArr2 = byteArr1.clone();
+ Memory mem1 = Memory.wrap(byteArr1);
+ Memory mem2 = Memory.wrap(byteArr2);
+ assertTrue(mem1.equalTo(0, mem2, 0, len));
+
+ byteArr2[thresh + 10] = (byte) (byteArr1[thresh + 10] + 1);
+ assertFalse(mem1.equalTo(0, mem2, 0, len));
+
+ byteArr2[thresh + 10] = byteArr1[thresh + 10];
+ byteArr2[(thresh * 2) + 3] = (byte) (byteArr1[(thresh * 2) + 3] + 1);
+ assertFalse(mem1.equalTo(0,mem2, 0, len));
+ }
+
+ @Test
+ public void checkWrapWithBO() {
+ WritableMemory wmem = WritableMemory.writableWrap(new byte[0], ByteOrder.BIG_ENDIAN);
+ boolean nativeBO = wmem.getTypeByteOrder() == ByteOrder.nativeOrder();
+ assertFalse(nativeBO);
+ println("" + nativeBO);
+ wmem = WritableMemory.writableWrap(new byte[8], ByteOrder.BIG_ENDIAN);
+ nativeBO = wmem.getTypeByteOrder() == ByteOrder.nativeOrder();
+ assertFalse(nativeBO);
+ println("" + nativeBO);
+ }
+
+ @Test
+ @SuppressWarnings("unused")
+ public void checkOwnerClientCase() {
+ WritableMemory owner = WritableMemory.allocate(64);
+ Memory client1 = owner; //Client1 cannot write (no API)
+ owner.putInt(0, 1); //But owner can write
+ ((WritableMemory)client1).putInt(0, 2); //Client1 can write, but with explicit effort.
+ Memory client2 = owner.region(0, owner.getCapacity()); //client2 cannot write (no API)
+ owner.putInt(0, 3); //But Owner should be able to write
+ }
+
+ @Test
+ public void printlnTest() {
+ println("PRINTING: "+this.getClass().getName());
+ }
+
+ /**
+ * @param s value to print
+ */
+ static void println(final String s) {
+ //System.out.println(s);
+ }
+
+}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/XxHash64LoopingTest.java b/src/test/java/org/apache/datasketches/memory/internal/XxHash64LoopingTest.java
new file mode 100644
index 0000000..6fc4f81
--- /dev/null
+++ b/src/test/java/org/apache/datasketches/memory/internal/XxHash64LoopingTest.java
@@ -0,0 +1,1082 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.datasketches.memory.internal;
+
+import static org.testng.Assert.assertEquals;
+
+import org.apache.datasketches.memory.WritableMemory;
+import org.testng.annotations.Test;
+
+/**
+ * @author Lee Rhodes
+ */
+public class XxHash64LoopingTest {
+
+ /*
+ * This test is adapted from
+ * <a href="https://github.com/OpenHFT/Zero-Allocation-Hashing/blob/master/src/test/java/net/openhft/hashing/XxHashTest.java">
+ * OpenHFT/Zero-Allocation-Hashing</a> to test hash compatibility with that implementation.
+ * See LICENSE.
+ */
+ @Test
+ public void testWithSeed() {
+ long seed = 42L;
+ for (int i = 0; i < 1025; i++) {
+ byte[] byteArr = new byte[i];
+ for (int j = 0; j < byteArr.length; j++) { byteArr[j] = (byte) j; }
+ WritableMemory wmem = WritableMemory.writableWrap(byteArr);
+ long hash = wmem.xxHash64(0, byteArr.length, seed);
+ assertEquals(hash, HASHES_OF_LOOPING_BYTES_WITH_SEED_42[i]);
+ }
+ }
+
+ /*This data is from
+ * <a href="https://github.com/OpenHFT/Zero-Allocation-Hashing/blob/master/src/test/java/net/openhft/hashing/XxHashTest.java">
+ * OpenHFT/Zero-Allocation-Hashing</a> to test hash compatibility with that implementation.
+ * See LICENSE.
+ */
+ private static final long[] HASHES_OF_LOOPING_BYTES_WITH_SEED_42 = {
+ -7444071767201028348L,
+ -8959994473701255385L,
+ 7116559933691734543L,
+ 6019482000716350659L,
+ -6625277557348586272L,
+ -5507563483608914162L,
+ 1540412690865189709L,
+ 4522324563441226749L,
+ -7143238906056518746L,
+ -7989831429045113014L,
+ -7103973673268129917L,
+ -2319060423616348937L,
+ -7576144055863289344L,
+ -8903544572546912743L,
+ 6376815151655939880L,
+ 5913754614426879871L,
+ 6466567997237536608L,
+ -869838547529805462L,
+ -2416009472486582019L,
+ -3059673981515537339L,
+ 4211239092494362041L,
+ 1414635639471257331L,
+ 166863084165354636L,
+ -3761330575439628223L,
+ 3524931906845391329L,
+ 6070229753198168844L,
+ -3740381894759773016L,
+ -1268276809699008557L,
+ 1518581707938531581L,
+ 7988048690914090770L,
+ -4510281763783422346L,
+ -8988936099728967847L,
+ -8644129751861931918L,
+ 2046936095001747419L,
+ 339737284852751748L,
+ -8493525091666023417L,
+ -3962890767051635164L,
+ -5799948707353228709L,
+ -6503577434416464161L,
+ 7718729912902936653L,
+ 191197390694726650L,
+ -2677870679247057207L,
+ 20411540801847004L,
+ 2738354376741059902L,
+ -3754251900675510347L,
+ -3208495075154651980L,
+ 5505877218642938179L,
+ 6710910171520780908L,
+ -9060809096139575515L,
+ 6936438027860748388L,
+ -6675099569841255629L,
+ -5358120966884144380L,
+ -4970515091611332076L,
+ -1810965683604454696L,
+ -516197887510505242L,
+ 1240864593087756274L,
+ 6033499571835033332L,
+ 7223146028771530185L,
+ 909128106589125206L,
+ 1567720774747329341L,
+ -1867353301780159863L,
+ 4655107429511759333L,
+ 5356891185236995950L,
+ 182631115370802890L,
+ -3582744155969569138L,
+ 595148673029792797L,
+ 495183136068540256L,
+ 5536689004903505647L,
+ -8472683670935785889L,
+ -4335021702965928166L,
+ 7306662983232020244L,
+ 4285260837125010956L,
+ 8288813008819191181L,
+ -3442351913745287612L,
+ 4883297703151707194L,
+ 9135546183059994964L,
+ 123663780425483012L,
+ 509606241253238381L,
+ 5940344208569311369L,
+ -2650142344608291176L,
+ 3232776678942440459L,
+ -922581627593772181L,
+ 7617977317085633049L,
+ 7154902266379028518L,
+ -5806388675416795571L,
+ 4368003766009575737L,
+ -2922716024457242064L,
+ 4771160713173250118L,
+ 3275897444752647349L,
+ -297220751499763878L,
+ 5095659287766176401L,
+ 1181843887132908826L,
+ 9058283605301070357L,
+ 3984713963471276643L,
+ 6050484112980480005L,
+ 1551535065359244224L,
+ 565337293533335618L,
+ 7412521035272884309L,
+ -4735469481351389369L,
+ 6998597101178745656L,
+ -9107075101236275961L,
+ 5879828914430779796L,
+ 6034964979406620806L,
+ 5666406915264701514L,
+ -4666218379625258428L,
+ 2749972203764815656L,
+ -782986256139071446L,
+ 6830581400521008570L,
+ 2588852022632995043L,
+ -5484725487363818922L,
+ -3319556935687817112L,
+ 6481961252981840893L,
+ 2204492445852963006L,
+ -5301091763401031066L,
+ -2615065677047206256L,
+ -6769817545131782460L,
+ -8421640685322953142L,
+ -3669062629317949176L,
+ -9167016978640750490L,
+ 2783671191687959562L,
+ -7599469568522039782L,
+ -7589134103255480011L,
+ -5932706841188717592L,
+ -8689756354284562694L,
+ -3934347391198581249L,
+ -1344748563236040701L,
+ 2172701592984478834L,
+ -5322052340624064417L,
+ -8493945390573620511L,
+ 3349021988137788403L,
+ -1806262525300459538L,
+ -8091524448239736618L,
+ 4022306289903960690L,
+ -8346915997379834224L,
+ -2106001381993805461L,
+ -5784123934724688161L,
+ 6775158099649720388L,
+ -3869682756870293568L,
+ 4356490186652082006L,
+ 8469371446702290916L,
+ -2972961082318458602L,
+ -7188106622222784561L,
+ -4961006366631572412L,
+ 3199991182014172900L,
+ 2917435868590434179L,
+ 8385845305547872127L,
+ 7706824402560674655L,
+ -1587379863634865277L,
+ -4212156212298809650L,
+ -1305209322000720233L,
+ -7866728337506665880L,
+ 8195089740529247049L,
+ -4876930125798534239L,
+ 798222697981617129L,
+ -2441020897729372845L,
+ -3926158482651178666L,
+ -1254795122048514130L,
+ 5192463866522217407L,
+ -5426289318796042964L,
+ -3267454004443530826L,
+ 471043133625225785L,
+ -660956397365869974L,
+ -6149209189144999161L,
+ -2630977660039166559L,
+ 8512219789663151219L,
+ -3309844068134074620L,
+ -6211275327487847132L,
+ -2130171729366885995L,
+ 6569302074205462321L,
+ 4855778342281619706L,
+ 3867211421508653033L,
+ -3002480002418725542L,
+ -8297543107467502696L,
+ 8049642289208775831L,
+ -5439825716055425635L,
+ 7251760070798756432L,
+ -4774526021749797528L,
+ -3892389575184442548L,
+ 5162451061244344424L,
+ 6000530226398686578L,
+ -5713092252241819676L,
+ 8740913206879606081L,
+ -8693282419677309723L,
+ 1576205127972543824L,
+ 5760354502610401246L,
+ 3173225529903529385L,
+ 1785166236732849743L,
+ -1024443476832068882L,
+ -7389053248306187459L,
+ 1171021620017782166L,
+ 1471572212217428724L,
+ 7720766400407679932L,
+ -8844781213239282804L,
+ -7030159830170200877L,
+ 2195066352895261150L,
+ 1343620937208608634L,
+ 9178233160016731645L,
+ -757883447602665223L,
+ 3303032934975960867L,
+ -3685775162104101116L,
+ -4454903657585596656L,
+ -5721532367620482629L,
+ 8453227136542829644L,
+ 5397498317904798888L,
+ 7820279586106842836L,
+ -2369852356421022546L,
+ 3910437403657116169L,
+ 6072677490463894877L,
+ -2651044781586183960L,
+ 5173762670440434510L,
+ -2970017317595590978L,
+ -1024698859439768763L,
+ -3098335260967738522L,
+ -1983156467650050768L,
+ -8132353894276010246L,
+ -1088647368768943835L,
+ -3942884234250555927L,
+ 7169967005748210436L,
+ 2870913702735953746L,
+ -2207022373847083021L,
+ 1104181306093040609L,
+ 5026420573696578749L,
+ -5874879996794598513L,
+ -4777071762424874671L,
+ -7506667858329720470L,
+ -2926679936584725232L,
+ -5530649174168373609L,
+ 5282408526788020384L,
+ 3589529249264153135L,
+ -6220724706210580398L,
+ -7141769650716479812L,
+ 5142537361821482047L,
+ -7029808662366864423L,
+ -6593520217660744466L,
+ 1454581737122410695L,
+ -139542971769349865L,
+ 1727752089112067235L,
+ -775001449688420017L,
+ -5011311035350652032L,
+ -8671171179275033159L,
+ -2850915129917664667L,
+ -5258897903906998781L,
+ -6954153088230718761L,
+ -4070351752166223959L,
+ -6902592976462171099L,
+ -7850366369290661391L,
+ -4562443925864904705L,
+ 3186922928616271015L,
+ 2208521081203400591L,
+ -2727824999830592777L,
+ -3817861137262331295L,
+ 2236720618756809066L,
+ -4888946967413746075L,
+ -446884183491477687L,
+ -43021963625359034L,
+ -5857689226703189898L,
+ -2156533592262354883L,
+ -2027655907961967077L,
+ 7151844076490292500L,
+ -5029149124756905464L,
+ 526404452686156976L,
+ 8741076980297445408L,
+ 7962851518384256467L,
+ -105985852299572102L,
+ -2614605270539434398L,
+ -8265006689379110448L,
+ 8158561071761524496L,
+ -6923530157382047308L,
+ 5551949335037580397L,
+ 565709346370307061L,
+ -4780869469938333359L,
+ 6931895917517004830L,
+ 565234767538051407L,
+ -8663136372880869656L,
+ 1427340323685448983L,
+ 6492705666640232290L,
+ 1481585578088475369L,
+ -1712711110946325531L,
+ 3281685342714380741L,
+ 6441384790483098576L,
+ -1073539554682358394L,
+ 5704050067194788964L,
+ -5495724689443043319L,
+ -5425043165837577535L,
+ 8349736730194941321L,
+ -4123620508872850061L,
+ 4687874980541143573L,
+ -468891940172550975L,
+ -3212254545038049829L,
+ -6830802881920725628L,
+ 9033050533972480988L,
+ 4204031879107709260L,
+ -677513987701096310L,
+ -3286978557209370155L,
+ 1644111582609113135L,
+ 2040089403280131741L,
+ 3323690950628902653L,
+ -7686964480987925756L,
+ -4664519769497402737L,
+ 3358384147145476542L,
+ -4699919744264452277L,
+ -4795197464927839170L,
+ 5051607253379734527L,
+ -8987703459734976898L,
+ 8993686795574431834L,
+ -2688919474688811047L,
+ 375938183536293311L,
+ 1049459889197081920L,
+ -1213022037395838295L,
+ 4932989235110984138L,
+ -6647247877090282452L,
+ -7698817539128166242L,
+ -3264029336002462659L,
+ 6487828018122309795L,
+ -2660821091484592878L,
+ 7104391069028909121L,
+ -1765840012354703384L,
+ 85428166783788931L,
+ -6732726318028261938L,
+ 7566202549055682933L,
+ 229664898114413280L,
+ -1474237851782211353L,
+ -1571058880058007603L,
+ -7926453582850712144L,
+ 2487148368914275243L,
+ 8740031015380673473L,
+ 1908345726881363169L,
+ -2510061320536523178L,
+ 7854780026906019630L,
+ -6023415596650016493L,
+ -6264841978089051107L,
+ 4024998278016087488L,
+ -4266288992025826072L,
+ -3222176619422665563L,
+ -1999258726038299316L,
+ 1715270077442385636L,
+ 6764658837948099754L,
+ -8646962299105812577L,
+ -51484064212171546L,
+ -1482515279051057493L,
+ -8663965522608868414L,
+ -256555202123523670L,
+ 1973279596140303801L,
+ -7280796173024508575L,
+ -5691760367231354704L,
+ -5915786562256300861L,
+ -3697715074906156565L,
+ 3710290115318541949L,
+ 6796151623958134374L,
+ -935299482515386356L,
+ -7078378973978660385L,
+ 5379481350768846927L,
+ -9011221735308556302L,
+ 5936568631579608418L,
+ -6060732654964511813L,
+ -4243141607840017809L,
+ 3198488845875349355L,
+ -7809288876010447646L,
+ 4371587872421472389L,
+ -1304197371105522943L,
+ 7389861473143460103L,
+ -1892352887992004024L,
+ 2214828764044713398L,
+ 6347546952883613388L,
+ 1275694314105480954L,
+ -5262663163358903733L,
+ 1524757505892047607L,
+ 1474285098416162746L,
+ -7976447341881911786L,
+ 4014100291977623265L,
+ 8994982266451461043L,
+ -7737118961020539453L,
+ -2303955536994331092L,
+ 1383016539349937136L,
+ 1771516393548245271L,
+ -5441914919967503849L,
+ 5449813464890411403L,
+ -3321280356474552496L,
+ 4084073849712624363L,
+ 4290039323210935932L,
+ 2449523715173349652L,
+ 7494827882138362156L,
+ 9035007221503623051L,
+ 5722056230130603177L,
+ -5443061851556843748L,
+ -7554957764207092109L,
+ 447883090204372074L,
+ 533916651576859197L,
+ -3104765246501904165L,
+ -4002281505194601516L,
+ -8402008431255610992L,
+ -408273018037005304L,
+ 214196458752109430L,
+ 6458513309998070914L,
+ 2665048360156607904L,
+ 96698248584467992L,
+ -3238403026096269033L,
+ 6759639479763272920L,
+ -4231971627796170796L,
+ -2149574977639731179L,
+ -1437035755788460036L,
+ -6000005629185669767L,
+ 145244292800946348L,
+ -3056352941404947199L,
+ 3748284277779018970L,
+ 7328354565489106580L,
+ -2176895260373660284L,
+ 3077983936372755601L,
+ 1215485830019410079L,
+ 683050801367331140L,
+ -3173237622987755212L,
+ -1951990779107873701L,
+ -4714366021269652421L,
+ 4934690664256059008L,
+ 1674823104333774474L,
+ -3974408282362828040L,
+ 2001478896492417760L,
+ -4115105568354384199L,
+ -2039694725495941666L,
+ -587763432329933431L,
+ -391276713546911316L,
+ -5543400904809469053L,
+ 1882564440421402418L,
+ -4991793588968693036L,
+ 3454088185914578321L,
+ 2290855447126188424L,
+ 3027910585026909453L,
+ 2136873580213167431L,
+ -6243562989966916730L,
+ 5887939953208193029L,
+ -3491821629467655741L,
+ -3138303216306660662L,
+ 8572629205737718669L,
+ 4154439973110146459L,
+ 5542921963475106759L,
+ -2025215496720103521L,
+ -4047933760493641640L,
+ -169455456138383823L,
+ -1164572689128024473L,
+ -8551078127234162906L,
+ -7247713218016599028L,
+ 8725299775220778242L,
+ 6263466461599623132L,
+ 7931568057263751768L,
+ 7365493014712655238L,
+ -7343740914722477108L,
+ 8294118602089088477L,
+ 7677867223984211483L,
+ -7052188421655969232L,
+ -3739992520633991431L,
+ 772835781531324307L,
+ 881441588914692737L,
+ 6321450879891466401L,
+ 5682516032668315027L,
+ 8493068269270840662L,
+ -3895212467022280567L,
+ -3241911302335746277L,
+ -7199586338775635848L,
+ -4606922569968527974L,
+ -806850906331637768L,
+ 2433670352784844513L,
+ -5787982146811444512L,
+ 7852193425348711165L,
+ 8669396209073850051L,
+ -6898875695148963118L,
+ 6523939610287206782L,
+ -8084962379210153174L,
+ 8159432443823995836L,
+ -2631068535470883494L,
+ -338649779993793113L,
+ 6514650029997052016L,
+ 3926259678521802094L,
+ 5443275905907218528L,
+ 7312187582713433551L,
+ -2993773587362997676L,
+ -1068335949405953411L,
+ 4499730398606216151L,
+ 8538015793827433712L,
+ -4057209365270423575L,
+ -1504284818438273559L,
+ -6460688570035010846L,
+ 1765077117408991117L,
+ 8278320303525164177L,
+ 8510128922449361533L,
+ 1305722765578569816L,
+ 7250861238779078656L,
+ -576624504295396147L,
+ -4363714566147521011L,
+ -5932111494795524073L,
+ 1837387625936544674L,
+ -4186755953373944712L,
+ -7657073597826358867L,
+ 140408487263951108L,
+ 5578463635002659628L,
+ 3400326044813475885L,
+ -6092804808386714986L,
+ -2410324417287268694L,
+ 3222007930183458970L,
+ 4932471983280850419L,
+ 3554114546976144528L,
+ -7216067928362857082L,
+ -6115289896923351748L,
+ -6769646077108881947L,
+ 4263895947722578066L,
+ 2939136721007694271L,
+ 1426030606447416658L,
+ -1316192446807442076L,
+ 5366182640480055129L,
+ 6527003877470258527L,
+ 5849680119000207603L,
+ 5263993237214222328L,
+ -6936533648789185663L,
+ -9063642143790846605L,
+ 3795892210758087672L,
+ 4987213125282940176L,
+ 2505500970421590750L,
+ -1014022559552365387L,
+ -3574736245968367770L,
+ 1180676507127340259L,
+ -2261908445207512503L,
+ -8416682633172243509L,
+ 1114990703652673283L,
+ 7753746660364401380L,
+ 1874908722469707905L,
+ 2033421444403047677L,
+ 21412168602505589L,
+ 385957952615286205L,
+ 2053171460074727107L,
+ 1915131899400103774L,
+ 6680879515029368390L,
+ 568807208929724162L,
+ -6211541450459087674L,
+ -5026690733412145448L,
+ 1384781941404886235L,
+ -98027820852587266L,
+ 1806580495924249669L,
+ 6322077317403503963L,
+ 9078162931419569939L,
+ -2809061215428363978L,
+ 7697867577577415733L,
+ -5270063855897737274L,
+ 5649864555290587388L,
+ -6970990547695444247L,
+ 579684606137331754L,
+ 3871931565451195154L,
+ 2030008578322050218L,
+ -5012357307111799829L,
+ -2271365921756144065L,
+ 4551962665158074190L,
+ -3385474923040271312L,
+ -7647625164191633577L,
+ 6634635380316963029L,
+ -5201190933687061585L,
+ 8864818738548593973L,
+ 2855828214210882907L,
+ 9154512990734024165L,
+ -6945306719789457786L,
+ 1200243352799481087L,
+ 875998327415853787L,
+ 1275313054449881011L,
+ -6105772045375948736L,
+ -2926927684328291437L,
+ 9200050852144954779L,
+ 5188726645765880663L,
+ 5197037323312705176L,
+ 3434926231010121611L,
+ -5054013669361906544L,
+ 2582959199749224670L,
+ -6053757512723474059L,
+ -5016308176846054473L,
+ -2509827316698626133L,
+ 7700343644503853204L,
+ -1997627249894596731L,
+ 3993168688325352290L,
+ -8181743677541277704L,
+ 3719056119682565597L,
+ -7264411659282947790L,
+ 7177028972346484464L,
+ -5460831176884283278L,
+ 1799904662416293978L,
+ -6549616005092764514L,
+ 5472403994001122052L,
+ 8683463751708388502L,
+ -7873363037838316398L,
+ 689134758256487260L,
+ -1287443614028696450L,
+ 4452712919702709507L,
+ 762909374167538893L,
+ 6594302592326281411L,
+ 1183786629674781984L,
+ 5021847859620133476L,
+ -2490098069181538915L,
+ 5105145136026716679L,
+ 4437836948098585718L,
+ 1987270426215858862L,
+ 6170312798826946249L,
+ 634297557126003407L,
+ -1672811625495999581L,
+ 6282971595586218191L,
+ 4549149305727581687L,
+ -5652165370435317782L,
+ 1064501550023753890L,
+ -5334885527127139723L,
+ -6904378001629481237L,
+ -1807576691784201230L,
+ -205688432992053911L,
+ 7621619053293393289L,
+ 6258649161313982470L,
+ -1111634238359342096L,
+ -8044260779481691987L,
+ 400270655839010807L,
+ -7806833581382890725L,
+ -2970563349459508036L,
+ -7392591524816802798L,
+ 2918924613160219805L,
+ -6444161627929149002L,
+ 6096497501321778876L,
+ -1477975665655830038L,
+ 1690651307597306138L,
+ -2364076888826085362L,
+ -6521987420014905821L,
+ -4419193480146960582L,
+ 3538587780233092477L,
+ 8374665961716940404L,
+ 7492412312405424500L,
+ 6311662249091276767L,
+ -1240235198282023566L,
+ 5478559631401166447L,
+ 3476714419313462133L,
+ 377427285984503784L,
+ 2570472638778991109L,
+ -2741381313777447835L,
+ -7123472905503039596L,
+ 2493658686946955193L,
+ 1024677789035847585L,
+ -2916713904339582981L,
+ -4532003852004642304L,
+ -2202143560366234111L,
+ 5832267856442755135L,
+ -261740607772957384L,
+ 239435959690278014L,
+ 5755548341947719409L,
+ 6138795458221887696L,
+ -7709506987360146385L,
+ -6657487758065140444L,
+ -7006376793203657499L,
+ 6544409861846502033L,
+ 3171929352014159247L,
+ 1051041925048792869L,
+ 2617300158375649749L,
+ 952652799620095175L,
+ -576661730162168147L,
+ -1634191369221345988L,
+ 4833656816115993519L,
+ 647566759700005786L,
+ 2473810683785291822L,
+ 3005977181064745326L,
+ -3321881966853149523L,
+ 7595337666427588699L,
+ 6004093624251057224L,
+ -563917505657690279L,
+ 6117428527147449302L,
+ -6287297509522976113L,
+ -4527219334756214406L,
+ 742626429298092489L,
+ 3057351806086972041L,
+ 645967551210272605L,
+ -4428701157828864227L,
+ 3236379103879435414L,
+ -8477089892132066300L,
+ -6127365537275859058L,
+ -4052490484706946358L,
+ -8004854976625046469L,
+ -3679456917426613424L,
+ -8212793762082595299L,
+ -818288739465424130L,
+ 1358812099481667095L,
+ 7835987612195254310L,
+ -3663247409614323059L,
+ -2931105150130396604L,
+ 7296136776835614792L,
+ -2014557408985889628L,
+ 7267662411237959788L,
+ 3699280615819277743L,
+ -212010675469091396L,
+ -6518374332458360120L,
+ 145026010541628849L,
+ 1879297324213501001L,
+ -7146296067751816833L,
+ -5002958800391379931L,
+ 6060682439924517608L,
+ -432234782921170964L,
+ -6669688947353256956L,
+ 7728943532792041267L,
+ 830911367341171721L,
+ 3396934884314289432L,
+ -779464156662780749L,
+ 2330041851883352285L,
+ -4783350380736276693L,
+ -5758476056890049254L,
+ -7551552301614791791L,
+ 1253334187723911710L,
+ -2685018208308798978L,
+ 5379636036360946454L,
+ 6154668487114681217L,
+ -8641287462255458898L,
+ 4676087643800649558L,
+ -2405142641398691475L,
+ 1088685126864246881L,
+ 6431149082338374041L,
+ -607357695335069155L,
+ -720970692129524140L,
+ 2648766932394044468L,
+ 8408344790179354573L,
+ -6193808387735667350L,
+ 7722524628524697419L,
+ -6975433852560238120L,
+ -2925851029234475295L,
+ -4274458387165211028L,
+ -8355836377702147319L,
+ 5278146397877332061L,
+ 8502098812383680707L,
+ 2292836642336580326L,
+ -6127608082651070062L,
+ 2222301962240611208L,
+ -1930887695854799378L,
+ 7640503480494894592L,
+ 1162652186586436094L,
+ -1918002592943761683L,
+ 7648998601717261840L,
+ -8472603250832757057L,
+ -988877663117552456L,
+ 2368458128168026494L,
+ -6480813811998475245L,
+ -5896967824416018967L,
+ -2593783161701820446L,
+ 6950098417530252598L,
+ 6362589545555771236L,
+ 7981389665448567125L,
+ 3954017080198558850L,
+ 1626078615050230622L,
+ 6650159066527969109L,
+ 697345338922935394L,
+ -1226816215461768626L,
+ 8740408765973837440L,
+ -4194155864629568323L,
+ 7016680023232424746L,
+ 6043281358142429469L,
+ -4201005667174376809L,
+ 1216727117859013155L,
+ 6367202436544203935L,
+ 35414869396444636L,
+ 3715622794033998412L,
+ 488654435687670554L,
+ -2503747297224687460L,
+ 3147101919441470388L,
+ -8248611218693190922L,
+ 970697264481229955L,
+ 3411465763826851418L,
+ 9117405004661599969L,
+ -5204346498331519734L,
+ -19637460819385174L,
+ -5039124225167977219L,
+ 2990108874601696668L,
+ -2623857460235459202L,
+ 4256291692861397446L,
+ 6724147860870760443L,
+ 3558616688507246537L,
+ 6487680097936412800L,
+ -6470792832935928161L,
+ 4314814550912237614L,
+ -1292878983006062345L,
+ 6791915152630414174L,
+ 5971652079925815310L,
+ 2557529546662864312L,
+ 466175054322801580L,
+ -585216717310746872L,
+ -2486640422147349036L,
+ 7212029603994220134L,
+ 3958995069888972500L,
+ 4950471855791412790L,
+ -3721948842035712763L,
+ -6184503487488243051L,
+ 4079570444585775332L,
+ -3952156172546996872L,
+ 4543894231118208322L,
+ -1739995588466209963L,
+ 9155948355455935530L,
+ 5821980345462207860L,
+ -2431287667309520417L,
+ -3890108130519441316L,
+ -558124689277030490L,
+ 6079823537335801717L,
+ 5409742395192364262L,
+ -2329885777717160453L,
+ -7332804342513677651L,
+ 1466490574975950555L,
+ -420549419907427929L,
+ -5249909814389692516L,
+ -5145692168206210661L,
+ 5934113980649113921L,
+ 3241618428555359661L,
+ -6622110266160980250L,
+ 5048250878669516223L,
+ 5747219637359976174L,
+ 2975906212588223728L,
+ 5730216838646273215L,
+ -176713127129024690L,
+ 6734624279336671146L,
+ 5127866734316017180L,
+ 7111761230887705595L,
+ 3457811808274317235L,
+ 3362961434604932375L,
+ -1877869936854991246L,
+ 7171428594877765665L,
+ -8252167178400462374L,
+ -6306888185035821047L,
+ -6684702191247683887L,
+ -7754928454824190529L,
+ -1902605599135704386L,
+ -4037319846689421239L,
+ 8493746058123583457L,
+ -8156648963857047193L,
+ 2051510355149839497L,
+ -1256416624177218909L,
+ -3344927996254072010L,
+ -1838853051925943568L,
+ 316927471680974556L,
+ -1502257066700798003L,
+ -5836095610125837606L,
+ -1594125583615895424L,
+ 1442211486559637962L,
+ -144295071206619569L,
+ 5159850900959273410L,
+ 4589139881166423678L,
+ -7038726987463097509L,
+ 2886082400772974595L,
+ 2780759114707171916L,
+ 5694649587906297495L,
+ 1260349041268169667L,
+ 4921517488271434890L,
+ 644696475796073018L,
+ 6262811963753436289L,
+ -6128198676595868773L,
+ -3625352083004760261L,
+ -8751453332943236675L,
+ 8749249479868749221L,
+ -2450808199545048250L,
+ -6517435817046180917L,
+ -3433321727429234998L,
+ -2591586258908763451L,
+ 3847750870868804507L,
+ 6603614438546398643L,
+ -7598682191291031287L,
+ 8710261565627204971L,
+ 4753389483755344355L,
+ -4645333069458786881L,
+ -6742695046613492214L,
+ 643070478568866643L,
+ -7543096104151965610L,
+ 7171495384655926161L,
+ 595063872610714431L,
+ 3292310150781130424L,
+ 4326847806055440904L,
+ -4580020566072794152L,
+ 3142286571820373678L,
+ 5530356537440155930L,
+ 546372639737516181L,
+ 7401214477400367500L,
+ 7406531960402873109L,
+ 3287639667219172570L,
+ 4977301681213633671L,
+ 5253257820925174498L,
+ 2906216636104297878L,
+ 6142955758238347523L,
+ -3498651268741727235L,
+ -5875053958265588593L,
+ 3896719087169993883L,
+ -910904726885775073L,
+ 380107493197368177L,
+ -4993591912695447004L,
+ 2970487257212582761L,
+ 2551762717569548774L,
+ 953061649962736812L,
+ 8949739538606589463L,
+ -2962839167079475801L,
+ -1375673191272573835L,
+ 3761793818361866390L,
+ -389577789190726878L,
+ 5661262051502180269L,
+ -6558556411143987683L,
+ -702798336372315031L,
+ -336662820551371779L,
+ 998576401126580155L,
+ -5945021269112582755L,
+ 6108533925730179871L,
+ 2207095297001999618L,
+ -9042779159998880435L,
+ -6177868444342118372L,
+ 6775965402605895077L,
+ -3788428885163306576L,
+ 7790055010527190387L,
+ 3581587652196995358L,
+ -6176354155561607694L,
+ -5859381340906321207L,
+ 395898765763528395L,
+ 8132967590863909348L,
+ -3329092504090544483L,
+ -6785855381158040247L,
+ 1497218517051796750L,
+ -5352392845588925911L,
+ -6271364901230559194L,
+ 2314830370653350118L,
+ -7617588269001325450L,
+ 1423166885758213795L,
+ 8538612578307869519L,
+ -61918791718295474L,
+ -8177103503192338593L,
+ -4740086042584326695L,
+ 3677931948215558698L,
+ 6558856291580149558L,
+ 2674975452453336335L,
+ 5133796555646930522L,
+ 5139252693299337100L,
+ 7949476871295347205L,
+ 4407815324662880678L,
+ -3758305875280581215L,
+ 6066309507576587415L,
+ -7368508486398350973L,
+ -3181640264332856492L,
+ 6905100869343314145L,
+ 3677177673848733417L,
+ 8862933624870506941L,
+ -8575223195813810568L,
+ 9178470351355678144L,
+ 4677809017145408358L,
+ -1194833416287894989L,
+ 3436364743255571183L,
+ -5204770725795363579L,
+ 560599448536335263L,
+ -3192077522964776200L,
+ -751575299648803575L,
+ 6334581746534596579L,
+ -8358187891202563300L,
+ -1462480609823525055L,
+ 5605961062646987941L,
+ 4968399805931440889L,
+ 7968693270782626653L,
+ -5868205923557518188L,
+ 1830234928743560617L,
+ -8435261076693154407L,
+ 2138416970728681332L,
+ 8088740745199685138L,
+ 806532400344230520L,
+ 1800590379902909333L,
+ -8909128842071238901L,
+ -7357495566969170860L,
+ 3679766664126940553L,
+ 2060050474865839094L,
+ 2363972840121763414L,
+ 525695004292982714L,
+ -1224842191746529593L,
+ 7011317848855545003L,
+ -6337167558180299938L,
+ -5184688833363785939L,
+ -8426673387248359061L,
+ -5035438815930785229L,
+ 3521810320608058994L,
+ 4803742557254962242L,
+ 6623527039545786598L,
+ -1221475882122634738L,
+ -3344794405518401087L,
+ 6510298498414053658L,
+ 2844753907937720338L,
+ 90502309714994895L,
+ -750403235344282494L,
+ -4825474181021465833L,
+ -3405519947983849510L,
+ 3503875590944089793L,
+ 7286294700691822468L,
+ 7828126881500292486L,
+ 8437899353709338096L,
+ 136052254470293480L,
+ 1113259077339995086L,
+ -8244887265606191121L,
+ 8089569503800461649L,
+ -1429698194850157567L,
+ 1575595674002364989L,
+ 3576095286627428675L,
+ -7653655285807569222L,
+ -6053506977362539111L,
+ -3923855345805787169L,
+ -8001149080454232377L,
+ -4382867706931832271L,
+ 4212860258835896297L,
+ 4207674254247034014L,
+ 5519424058779519159L,
+ -754483042161434654L,
+ 1434113479814210082L,
+ -6416645032698336896L,
+ 5624329676066514819L,
+ -8229557208322175959L,
+ 3922640911653270376L,
+ 7826932478782081910L,
+ -4862787164488635842L,
+ 1449234668827944573L,
+ -1781657689570106327L,
+ 5442827552725289699L,
+ 3589862161007644641L,
+ 4787115581650652778L,
+ -3512152721942525726L,
+ -6750103117958685206L,
+ 5012970446659949261L,
+ 6797752795961689017L,
+ 5086454597639943700L,
+ -7616068364979994076L,
+ 1492846825433110217L,
+ 2967476304433704510L,
+ -8413824338284112078L,
+ -1319049442043273974L,
+ -1756090916806844109L,
+ -9061091728950139525L,
+ -6864767830358160810L,
+ 4879532090226251157L,
+ 5528644708740739488L
+ };
+}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/XxHash64Test.java b/src/test/java/org/apache/datasketches/memory/internal/XxHash64Test.java
new file mode 100644
index 0000000..81a682a
--- /dev/null
+++ b/src/test/java/org/apache/datasketches/memory/internal/XxHash64Test.java
@@ -0,0 +1,179 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.datasketches.memory.internal;
+
+import static org.apache.datasketches.memory.XxHash.*;
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertTrue;
+
+import java.util.Random;
+import java.util.concurrent.ThreadLocalRandom;
+
+import org.apache.datasketches.memory.BaseState;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.WritableMemory;
+import org.testng.annotations.Test;
+
+import net.openhft.hashing.LongHashFunction;
+
+/**
+ * @author Lee Rhodes
+ */
+public class XxHash64Test {
+
+ @Test
+ public void offsetChecks() {
+ long seed = 12345;
+ int blocks = 6;
+ int cap = blocks * 16;
+
+ long hash;
+
+ 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++) {
+ int arrLen = cap - offset;
+ hash = wmem.xxHash64(offset, arrLen, seed);
+ assertTrue(hash != 0);
+ }
+ }
+
+ @Test
+ public void byteArrChecks() {
+ long seed = 0;
+ int offset = 0;
+ int bytes = 16;
+
+ for (int j = 1; j < bytes; j++) {
+ byte[] in = new byte[bytes];
+
+ 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);
+ assertTrue(hash != 0);
+ }
+ }
+
+ /*
+ * This test is adapted from
+ * <a href="https://github.com/OpenHFT/Zero-Allocation-Hashing/blob/master/
+ * src/test/java/net/openhft/hashing/XxHashCollisionTest.java">
+ * OpenHFT/Zero-Allocation-Hashing</a> to test hash compatibility with that implementation.
+ * It is licensed under Apache License, version 2.0. See LICENSE.
+ */
+ @Test
+ public void collisionTest() {
+ WritableMemory wmem = WritableMemory.allocate(128);
+ wmem.putLong(0, 1);
+ wmem.putLong(16, 42);
+ wmem.putLong(32, 2);
+ long h1 = wmem.xxHash64(0, wmem.getCapacity(), 0);
+
+ wmem.putLong(0, 1L + 0xBA79078168D4BAFL);
+ wmem.putLong(32, 2L + 0x9C90005B80000000L);
+ long h2 = wmem.xxHash64(0, wmem.getCapacity(), 0);
+ assertEquals(h1, h2);
+
+ wmem.putLong(0, 1L + (0xBA79078168D4BAFL * 2));
+ wmem.putLong(32, 2L + (0x392000b700000000L)); //= (0x9C90005B80000000L * 2) fix overflow false pos
+
+ long h3 = wmem.xxHash64(0, wmem.getCapacity(), 0);
+ assertEquals(h2, h3);
+ }
+
+ /**
+ * 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 increases confidence that the xxHash function implemented
+ * in this package is in fact the same xxHash function implemented in C.
+ *
+ * @author Roman Leventov
+ * @author Lee Rhodes
+ */
+ @Test
+ public void testXxHash() {
+ Random random = ThreadLocalRandom.current();
+ for (int len = 0; len < 100; len++) {
+ byte[] bytes = new byte[len];
+ for (int i = 0; i < 10; i++) {
+ long zahXxHash = LongHashFunction.xx().hashBytes(bytes);
+ long memoryXxHash = Memory.wrap(bytes).xxHash64(0, len, 0);
+ assertEquals(memoryXxHash, zahXxHash);
+ random.nextBytes(bytes);
+ }
+ }
+ }
+
+ private static final byte[] barr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
+
+ @Test
+ public void testArrHashes() {
+ WritableMemory wmem = WritableMemory.writableWrap(barr);
+ long hash0 = wmem.xxHash64(8, 8, 0);
+ long hash1 = hashByteArr(barr, 8, 8, 0);
+ assertEquals(hash1, hash0);
+
+ char[] carr = new char[8];
+ wmem.getCharArray(0, carr, 0, 8);
+ hash1 = hashCharArr(carr, 4, 4, 0);
+ assertEquals(hash1, hash0);
+
+ short[] sarr = new short[8];
+ wmem.getShortArray(0, sarr, 0, 8);
+ hash1 = hashShortArr(sarr, 4, 4, 0);
+ assertEquals(hash1, hash0);
+
+ int[] iarr = new int[4];
+ wmem.getIntArray(0, iarr, 0, 4);
+ hash1 = hashIntArr(iarr, 2, 2, 0);
+ assertEquals(hash1, hash0);
+
+ float[] farr = new float[4];
+ wmem.getFloatArray(0, farr, 0, 4);
+ hash1 = hashFloatArr(farr, 2, 2, 0);
+ assertEquals(hash1, hash0);
+
+ long[] larr = new long[2];
+ wmem.getLongArray(0, larr, 0, 2);
+ hash1 = hashLongArr(larr, 1, 1, 0);
+ long in = wmem.getLong(8);
+ long hash2 = hashLong(in, 00); //tests the single long hash
+ assertEquals(hash1, hash0);
+ assertEquals(hash2, hash0);
+
+ double[] darr = new double[2];
+ wmem.getDoubleArray(0, darr, 0, 2);
+ hash1 = hashDoubleArr(darr, 1, 1, 0);
+ assertEquals(hash1, hash0);
+
+ }
+
+ @Test
+ public void testString() {
+ String s = "Now is the time for all good men to come to the aid of their country.";
+ char[] arr = s.toCharArray();
+ long hash0 = hashString(s, 0, s.length(), 0);
+ long hash1 = hashCharArr(arr, 0, arr.length, 0);
+ assertEquals(hash1, hash0);
+ }
+
+}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/ZeroCapacityTest.java b/src/test/java/org/apache/datasketches/memory/internal/ZeroCapacityTest.java
new file mode 100644
index 0000000..4c03459
--- /dev/null
+++ b/src/test/java/org/apache/datasketches/memory/internal/ZeroCapacityTest.java
@@ -0,0 +1,76 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.datasketches.memory.internal;
+
+import static org.testng.Assert.assertEquals;
+
+import java.nio.ByteBuffer;
+
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.WritableMemory;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import jdk.incubator.foreign.ResourceScope;
+
+/**
+ * @author Lee Rhodes
+ */
+public class ZeroCapacityTest {
+ private final MemoryRequestServer memReqSvr = new DefaultMemoryRequestServer();
+
+ @SuppressWarnings("resource")
+ @Test
+ public void checkZeroCapacity() throws Exception {
+ WritableMemory wmem = WritableMemory.allocate(0);
+ assertEquals(wmem.getCapacity(), 0);
+
+ Memory.wrap(new byte[0]);
+ Memory.wrap(ByteBuffer.allocate(0));
+ Memory mem3 = Memory.wrap(ByteBuffer.allocateDirect(0));
+ mem3.region(0, 0);
+ WritableMemory nullMem = null;
+ ResourceScope scope = ResourceScope.newConfinedScope();
+ try { //Invalid allocation size : 0
+ nullMem = WritableMemory.allocateDirect(0, scope, memReqSvr);
+ Assert.fail();
+ } catch (IllegalArgumentException ignore) {
+ if (nullMem != null) {
+ nullMem.close();
+ }
+ // expected
+ }
+ }
+
+ @Test
+ public void printlnTest() {
+ //println("PRINTING: "+this.getClass().getName());
+ }
+
+ /**
+ * @param s value to print
+ */
+ static void println(String s) {
+ //System.out.println(s); //disable here
+ }
+
+}
diff --git a/src/test/java/org/apache/datasketches/memory/test/ReflectUtil.java b/src/test/java/org/apache/datasketches/memory/test/ReflectUtil.java
deleted file mode 100644
index f57a49c..0000000
--- a/src/test/java/org/apache/datasketches/memory/test/ReflectUtil.java
+++ /dev/null
@@ -1,399 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package org.apache.datasketches.memory.test;
-
-import java.io.File;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.nio.ByteOrder;
-
-import org.apache.datasketches.memory.MemoryRequestServer;
-
-public final class ReflectUtil {
-
- private ReflectUtil() {}
-
- static final Class<?> BASE_STATE;
- static final Class<?> BASE_WRITABLE_MEMORY_IMPL;
- static final Class<?> ALLOCATE_DIRECT_MAP;
- static final Class<?> NIO_BITS;
-
- static final Method CHECK_VALID; //BaseStateImpl
- static final Method GET_DIRECT_ALLOCATIONS_COUNT; //NioBits
- static final Method GET_MAX_DIRECT_BYTE_BUFFER_MEMORY; //NioBits
- static final Method GET_NATIVE_BASE_OFFSET; //BaseStateImpl
- static final Method GET_RESERVED_MEMORY; //NioBits
- static final Method GET_TOTAL_CAPACITY; //NioBits
- static final Method GET_UNSAFE_OBJECT; //BaseStateImpl
- static final Method IS_BB_TYPE; //BaseStateImpl
- static final Method IS_BUFFER_TYPE; //BaseStateImpl
- static final Method IS_DIRECT_TYPE; //BaseStateImpl
- static final Method IS_DUPLICATE_TYPE; //BaseStateImpl
- static final Method IS_FILE_READ_ONLY; //AllocateDirectMap
- static final Method IS_HEAP_TYPE; //BaseStateImpl
- static final Method IS_MAP_TYPE; //BaseStateImpl
- static final Method IS_NON_NATIVE_TYPE; //BaseStateImpl
- static final Method IS_PAGE_ALIGHED; //NioBits
- static final Method IS_READ_ONLY_TYPE; //BaseStateImpl
- static final Method IS_REGION_TYPE; //BaseStateImpl
- static final Method PAGE_COUNT; //NioBits
- static final Method PAGE_SIZE; //NioBits
- static final Method RESERVE_MEMORY; //NioBits
- static final Method UNRESERVE_MEMORY; //NioBits
- static final Method WRAP_DIRECT; //BaseWritableMemoryImpl
-
- static {
- BASE_STATE =
- getClass("org.apache.datasketches.memory.internal.BaseStateImpl");
- BASE_WRITABLE_MEMORY_IMPL =
- getClass("org.apache.datasketches.memory.internal.BaseWritableMemoryImpl");
- ALLOCATE_DIRECT_MAP =
- getClass("org.apache.datasketches.memory.internal.AllocateDirectMap");
- NIO_BITS =
- getClass("org.apache.datasketches.memory.internal.NioBits");
-
- CHECK_VALID =
- getMethod(BASE_STATE, "checkValid", (Class<?>[])null); //not static
- GET_DIRECT_ALLOCATIONS_COUNT =
- getMethod(NIO_BITS, "getDirectAllocationsCount", (Class<?>[])null); //static
- GET_MAX_DIRECT_BYTE_BUFFER_MEMORY =
- getMethod(NIO_BITS, "getMaxDirectByteBufferMemory", (Class<?>[])null); //static
- GET_NATIVE_BASE_OFFSET =
- getMethod(BASE_STATE, "getNativeBaseOffset", (Class<?>[])null);
- GET_RESERVED_MEMORY =
- getMethod(NIO_BITS, "getReservedMemory", (Class<?>[])null); //static
- GET_TOTAL_CAPACITY =
- getMethod(NIO_BITS, "getTotalCapacity", (Class<?>[])null); //static
- GET_UNSAFE_OBJECT =
- getMethod(BASE_STATE, "getUnsafeObject", (Class<?>[])null); //not static
- IS_BB_TYPE =
- getMethod(BASE_STATE, "isBBType", (Class<?>[])null); //not static
- IS_BUFFER_TYPE =
- getMethod(BASE_STATE, "isBufferType", (Class<?>[])null); //not static
- IS_DIRECT_TYPE =
- getMethod(BASE_STATE, "isDirectType", (Class<?>[])null); //not static
- IS_DUPLICATE_TYPE =
- getMethod(BASE_STATE, "isDuplicateType", (Class<?>[])null); //not static
- IS_FILE_READ_ONLY =
- getMethod(ALLOCATE_DIRECT_MAP, "isFileReadOnly", File.class);
- IS_HEAP_TYPE =
- getMethod(BASE_STATE, "isHeapType", (Class<?>[])null); //not static
- IS_MAP_TYPE =
- getMethod(BASE_STATE, "isMapType", (Class<?>[])null); //not static
- IS_NON_NATIVE_TYPE =
- getMethod(BASE_STATE, "isNonNativeType", (Class<?>[])null); //not static
- IS_PAGE_ALIGHED =
- getMethod(NIO_BITS, "isPageAligned", (Class<?>[])null); //static
- IS_READ_ONLY_TYPE =
- getMethod(BASE_STATE, "isReadOnlyType", (Class<?>[])null); //not static
- IS_REGION_TYPE =
- getMethod(BASE_STATE, "isRegionType", (Class<?>[])null); //not static
- PAGE_COUNT =
- getMethod(NIO_BITS, "pageCount", long.class); //static
- PAGE_SIZE =
- getMethod(NIO_BITS, "pageSize", (Class<?>[])null); //static
- RESERVE_MEMORY =
- getMethod(NIO_BITS, "reserveMemory", long.class, long.class); //static
- UNRESERVE_MEMORY =
- getMethod(NIO_BITS, "unreserveMemory", long.class, long.class); //static
- WRAP_DIRECT =
- getMethod(BASE_WRITABLE_MEMORY_IMPL,
- "wrapDirect", long.class, ByteOrder.class, MemoryRequestServer.class); //static method
- }
-
- /**
- * Gets a Class reference to the given class loaded by the SystemClassLoader.
- * This will work for private, package-private and abstract classes.
- * @param fullyQualifiedBinaryName the binary name is the name of the class file on disk. This does not instantiate
- * a concrete class, but allows access to constructors, static fields and static methods.
- * @return the Class object of the given class.
- */
- public static Class<?> getClass(final String fullyQualifiedBinaryName) {
- try {
- final ClassLoader scl = ClassLoader.getSystemClassLoader();
- return scl.loadClass(fullyQualifiedBinaryName);
- } catch (final ClassNotFoundException e) {
- throw new RuntimeException(e);
- }
- }
-
- /**
- * Gets a declared constructor given the owner class and parameter types
- * @param ownerClass the Class<?> object of the class loaded by the SystemClassLoader.
- * @param parameterTypes parameter types for the constructor
- * @return the constructor
- */
- public static Constructor<?> getConstructor(final Class<?> ownerClass, final Class<?>... parameterTypes ) {
- try {
- final Constructor<?> ctor = ownerClass.getDeclaredConstructor(parameterTypes);
- ctor.setAccessible(true);
- return ctor;
- } catch (final NoSuchMethodException | SecurityException e) {
- throw new RuntimeException(e);
- }
- }
-
- /**
- * Gets a class instance from its constructor and initializing arguments.
- * @param constructor the given Constructor
- * @param initargs the initializing arguments
- * @return the instantiated class.
- */
- public static Object getInstance(final Constructor<?> constructor, final Object... initargs) {
- try {
- constructor.setAccessible(true);
- return constructor.newInstance(initargs);
- } catch (final InstantiationException | IllegalAccessException | IllegalArgumentException
- | InvocationTargetException | SecurityException e) {
- throw new RuntimeException(e);
- }
- }
-
- /**
- * Gets a declared field of the given the loaded owner class and field name. The accessible flag will be set true.
- * @param ownerClass the Class<?> object of the class loaded by the SystemClassLoader.
- * @param fieldName the desired field name
- * @return the desired field.
- */
- public static Field getField(final Class<?> ownerClass, final String fieldName) {
- try {
- final Field field = ownerClass.getDeclaredField(fieldName);
- field.setAccessible(true);
- return field;
- } catch (final NoSuchFieldException | SecurityException e) {
- throw new RuntimeException(e);
- }
- }
-
- /**
- * Gets a field value given the loaded owner class and the Field. The accessible flag will be set true.
- * @param ownerClass the loaded class owning the field
- * @param field The Field object
- * @return the returned value as an object.
- */
- public static Object getFieldValue(final Class<?> ownerClass, final Field field) {
- try {
- field.setAccessible(true);
- return field.get(ownerClass);
- } catch (final IllegalAccessException | SecurityException | IllegalArgumentException e) {
- throw new RuntimeException(e);
- }
- }
-
- /**
- * Gets a declared method of the given the loaded owning class, method name and parameter types.
- * The accessible flag will be set true.
- * @param ownerClass the given owner class
- * @param methodName the given method name
- * @param parameterTypes the list of parameter types
- * @return the desired method.
- */
- public static Method getMethod(
- final Class<?> ownerClass, final String methodName, final Class<?>... parameterTypes ) {
- try {
- final Method method = (parameterTypes == null)
- ? ownerClass.getDeclaredMethod(methodName)
- : ownerClass.getDeclaredMethod(methodName, parameterTypes);
- method.setAccessible(true);
- return method;
- } catch (final NoSuchMethodException | SecurityException e) {
- throw new RuntimeException(e);
- }
- }
-
- static void checkValid(final Object target) {
- try {
- CHECK_VALID.invoke(target);
- } catch (final IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
- throw new RuntimeException(e);
- }
- }
-
- static long getDirectAllocationsCount() {
- try {
- return (long) GET_DIRECT_ALLOCATIONS_COUNT.invoke(null);
- } catch (final IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
- throw new RuntimeException(e);
- }
- }
-
- static long getMaxDirectByteBufferMemory() {
- try {
- return (long) GET_MAX_DIRECT_BYTE_BUFFER_MEMORY.invoke(null);
- } catch (final IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
- throw new RuntimeException(e);
- }
- }
-
- static long getNativeBaseOffset(final Object target) {
- try {
- return (long) GET_NATIVE_BASE_OFFSET.invoke(target);
- } catch (final IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
- throw new RuntimeException(e);
- }
- }
-
- static long getReservedMemory() {
- try {
- return (long) GET_RESERVED_MEMORY.invoke(null);
- } catch (final IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
- throw new RuntimeException(e);
- }
- }
-
- static long getTotalCapacity() {
- try {
- return (long) GET_TOTAL_CAPACITY.invoke(null);
- } catch (final IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
- throw new RuntimeException(e);
- }
- }
-
- static Object getUnsafeObject(final Object target) {
- try {
- return GET_UNSAFE_OBJECT.invoke(target);
- } catch (final IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
- throw new RuntimeException(e);
- }
- }
-
- static boolean isBBType(final Object target) {
- try {
- return (boolean) IS_BB_TYPE.invoke(target);
- } catch (final IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
- throw new RuntimeException(e);
- }
- }
-
- static boolean isBufferType(final Object target) {
- try {
- return (boolean) IS_BUFFER_TYPE.invoke(target);
- } catch (final IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
- throw new RuntimeException(e);
- }
- }
-
- static boolean isDirectType(final Object target) {
- try {
- return (boolean) IS_DIRECT_TYPE.invoke(target);
- } catch (final IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
- throw new RuntimeException(e);
- }
- }
-
- static boolean isDuplicateType(final Object target) {
- try {
- return (boolean) IS_DUPLICATE_TYPE.invoke(target);
- } catch (final IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
- throw new RuntimeException(e);
- }
- }
-
- static boolean isFileReadOnly(final File file) {
- try {
- return (boolean) IS_FILE_READ_ONLY.invoke(null, file);
- } catch (final IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
- throw new RuntimeException(e);
- }
- }
-
- static boolean isHeapType(final Object target) {
- try {
- return (boolean) IS_HEAP_TYPE.invoke(target);
- } catch (final IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
- throw new RuntimeException(e);
- }
- }
-
- static boolean isMapType(final Object target) {
- try {
- return (boolean) IS_MAP_TYPE.invoke(target);
- } catch (final IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
- throw new RuntimeException(e);
- }
- }
-
- static boolean isNonNativeType(final Object target) {
- try {
- return (boolean) IS_NON_NATIVE_TYPE.invoke(target);
- } catch (final IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
- throw new RuntimeException(e);
- }
- }
-
- static boolean isPageAligned() {
- try {
- return (boolean) IS_PAGE_ALIGHED.invoke(null);
- } catch (final IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
- throw new RuntimeException(e);
- }
- }
-
- static boolean isReadOnlyType(final Object target) {
- try {
- return (boolean) IS_READ_ONLY_TYPE.invoke(target);
- } catch (final IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
- throw new RuntimeException(e);
- }
- }
-
- static boolean isRegionType(final Object target) {
- try {
- return (boolean) IS_REGION_TYPE.invoke(target);
- } catch (final IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
- throw new RuntimeException(e);
- }
- }
-
- static int pageCount(final long bytes) {
- try {
- return (int) PAGE_COUNT.invoke(null, bytes);
- } catch (final IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
- throw new RuntimeException(e);
- }
- }
-
- static int pageSize() {
- try {
- return (int) PAGE_SIZE.invoke(null);
- } catch (final IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
- throw new RuntimeException(e);
- }
- }
-
- static void reserveMemory(final long allocationSize, final long capacity) {
- try {
- RESERVE_MEMORY.invoke(null, allocationSize, capacity);
- } catch (final IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
- throw new RuntimeException(e);
- }
- }
-
- static void unreserveMemory(final long allocationSize, final long capacity) {
- try {
- UNRESERVE_MEMORY.invoke(null, allocationSize, capacity);
- } catch (final IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
- throw new RuntimeException(e);
- }
- }
-
-}
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datasketches.apache.org
For additional commands, e-mail: commits-help@datasketches.apache.org