/// <summary>
/// Fake Copy method.
/// </summary>
public override void Copy(int offset, NativeMemoryChunk other, int otherOffset, int count)
{
FakeNativeMemoryChunk that = (FakeNativeMemoryChunk)other;
int numToCopy = Math.Min(count, _buf.Length - offset);
Array.Copy(_buf, offset, that._buf, otherOffset, numToCopy);
}
public void TestDispose()
{
int size = 128;
NativeMemoryChunk nativeMemoryChunk = new NativeMemoryChunk(size);
nativeMemoryChunk.Dispose();
Assert.IsTrue(nativeMemoryChunk.Closed);
}
public void TestIsReusable()
{
NativeMemoryChunk chunk = _pool.Get(1);
Assert.IsTrue(_pool.IsReusable(chunk));
chunk.Dispose();
Assert.IsFalse(_pool.IsReusable(chunk));
}
public void TestAlloc()
{
int size = 128;
using (NativeMemoryChunk nativeMemoryChunk = new NativeMemoryChunk(size))
{
Assert.IsNotNull(nativeMemoryChunk);
}
}
public void TestFree()
{
NativeMemoryChunk c = _pool.Alloc(1);
Assert.IsFalse(c.Closed);
_pool.Free(c);
Assert.IsTrue(c.Closed);
_pool.Free(c);
Assert.IsTrue(c.Closed);
}
public void TestAlloc()
{
NativeMemoryChunk c = _pool.Alloc(1);
Assert.IsNotNull(c);
Assert.AreEqual(1, c.Size);
Assert.AreEqual(1, _pool.Alloc(1).Size);
Assert.AreEqual(33, _pool.Alloc(33).Size);
Assert.AreEqual(32, _pool.Alloc(32).Size);
}
public void TestWrite()
{
int size = 128;
byte value = 1;
using (NativeMemoryChunk nativeMemoryChunk = new NativeMemoryChunk(size))
{
byte[] src = Enumerable.Repeat(value, size).ToArray();
Assert.AreEqual(size, nativeMemoryChunk.Write(0, src, 0, size));
}
}
public void TestWriteInvalidCount()
{
int size = 128;
byte value = 1;
int offset = 30;
using (NativeMemoryChunk nativeMemoryChunk = new NativeMemoryChunk(size))
{
byte[] src = Enumerable.Repeat(value, size).ToArray();
Assert.AreEqual(size - offset, nativeMemoryChunk.Write(offset, src, 0, size));
}
}
public void Initialize()
{
_chunk = new FakeNativeMemoryChunk(BYTES.Length);
_chunk.Write(0, BYTES, 0, BYTES.Length);
_pool = new FakeNativeMemoryChunkPool();
var poolRef = CloseableReference <NativeMemoryChunk> .of(_chunk, _pool);
_pooledByteBuffer = new NativePooledByteBuffer(
poolRef,
BUFFER_LENGTH);
poolRef.Dispose();
}
public void TestWriteInvalidCount2()
{
int size = 128;
byte value = 1;
int offset = 30;
using (NativeMemoryChunk nativeMemoryChunk = new NativeMemoryChunk(size))
{
byte[] src = Enumerable.Repeat(value, size).ToArray();
try
{
nativeMemoryChunk.Write(0, src, offset, size);
Assert.Fail();
}
catch (ArgumentException)
{
// This is expected
}
}
}
public void TestCopy()
{
int size = 128;
using (NativeMemoryChunk nativeMemoryChunk = new NativeMemoryChunk(size),
nativeMemoryChunk2 = new NativeMemoryChunk(size))
{
byte[] src = new byte[size];
for (int i = 0; i < size; ++i)
{
src[i] = (byte)i;
}
nativeMemoryChunk.Write(0, src, 0, size);
nativeMemoryChunk.Copy(0, nativeMemoryChunk2, 0, size);
for (int i = 0; i < size; ++i)
{
Assert.AreEqual(nativeMemoryChunk.Read(i), nativeMemoryChunk2.Read(i));
}
}
}
public void TestReadArray()
{
int size = 128;
using (NativeMemoryChunk nativeMemoryChunk = new NativeMemoryChunk(size))
{
byte[] src = new byte[size];
for (int i = 0; i < size; ++i)
{
src[i] = (byte)i;
}
nativeMemoryChunk.Write(0, src, 0, size);
byte[] dst = new byte[size];
nativeMemoryChunk.Read(0, dst, 0, size);
for (int i = 0; i < size; ++i)
{
Assert.AreEqual(src[i], dst[i]);
}
}
}
