public async Task WriteAsyncMemory_WrapsNative_DelegatesToWrite_Success()
{
bool writeInvoked = false;
var s = new DelegateStream(
canWriteFunc: () => true,
writeAsyncFunc: (array, offset, count, cancellationToken) =>
{
writeInvoked = true;
Assert.NotNull(array);
Assert.Equal(0, offset);
Assert.Equal(3, count);
for (int i = 0; i < count; i++)
{
Assert.Equal(i, array[i]);
}
return(Task.CompletedTask);
});
using (var nativeMemory = new NativeOwnedMemory(10))
{
Memory <byte> memory = nativeMemory.Memory;
memory.Span[2] = 0;
memory.Span[3] = 1;
memory.Span[4] = 2;
await s.WriteAsync(memory.Slice(2, 3));
Assert.True(writeInvoked);
writeInvoked = false;
}
}
public async Task ReadAsyncMemory_WrapsNative_DelegatesToReadAsyncArrayWithPool_Success()
{
bool readInvoked = false;
var s = new DelegateStream(
canReadFunc: () => true,
readAsyncFunc: (array, offset, count, cancellationToken) =>
{
readInvoked = true;
Assert.NotNull(array);
Assert.Equal(0, offset);
Assert.Equal(20, count);
for (int i = 0; i < 10; i++)
{
array[offset + i] = (byte)i;
}
return(Task.FromResult(10));
});
using (var totalNativeMemory = new NativeOwnedMemory(30))
{
Memory <byte> totalMemory = totalNativeMemory.Memory;
Memory <byte> targetMemory = totalMemory.Slice(5, 20);
Assert.Equal(10, await s.ReadAsync(targetMemory));
Assert.True(readInvoked);
for (int i = 0; i < 10; i++)
{
Assert.Equal(i, targetMemory.Span[i]);
}
readInvoked = false;
}
}
public async Task NonEmptyFile_CustomOwnedMemory_ReadAsync_GetsExpectedData()
{
string fileName = GetTestFilePath();
File.WriteAllBytes(fileName, TestBuffer);
using (var fs = CreateFileStream(fileName, FileMode.Open))
using (var buffer = new NativeOwnedMemory(TestBuffer.Length))
{
Assert.Equal(TestBuffer.Length, await fs.ReadAsync(buffer.Memory));
Assert.Equal <byte>(TestBuffer, buffer.Memory.ToArray());
}
}
public async Task NonEmptyWriteAsync_CustomOwnedMemory_WritesExpectedData()
{
using (var mem = new NativeOwnedMemory(TestBuffer.Length))
using (var fs = CreateFileStream(GetTestFilePath(), FileMode.Create))
{
new Memory <byte>(TestBuffer).CopyTo(mem.Memory);
await fs.WriteAsync(mem.Memory);
Assert.Equal(TestBuffer.Length, fs.Length);
Assert.Equal(TestBuffer.Length, fs.Position);
fs.Position = 0;
var buffer = new byte[TestBuffer.Length];
Assert.Equal(TestBuffer.Length, await fs.ReadAsync(new Memory <byte>(buffer)));
Assert.Equal(TestBuffer, buffer);
}
}
