public void Complete_EmptyBuffer()
{
using (var sliceBuffer = SliceBufferSafeHandle.Create())
{
sliceBuffer.Complete();
CollectionAssert.AreEqual(new byte[0], sliceBuffer.ToByteArray());
}
}
public void SliceBuffer_NegativeSizeHint()
{
using (var sliceBuffer = SliceBufferSafeHandle.Create())
{
Assert.Throws(typeof(ArgumentException), () => sliceBuffer.GetSpan(-1));
Assert.Throws(typeof(ArgumentException), () => sliceBuffer.GetMemory(-1));
}
}
public void SliceBuffer_AdvanceBadArg()
{
using (var sliceBuffer = SliceBufferSafeHandle.Create())
{
int size = 10;
var destSpan = sliceBuffer.GetSpan(size);
Assert.Throws(typeof(ArgumentException), () => sliceBuffer.Advance(size + 1));
Assert.Throws(typeof(ArgumentException), () => sliceBuffer.Advance(-1));
}
}
public void Complete_TailSizeZero()
{
using (var sliceBuffer = SliceBufferSafeHandle.Create())
{
var origPayload = GetTestBuffer(10);
origPayload.AsSpan().CopyTo(sliceBuffer.GetSpan(origPayload.Length));
sliceBuffer.Advance(origPayload.Length);
// call complete where tail space size == 0
sliceBuffer.Complete();
CollectionAssert.AreEqual(origPayload, sliceBuffer.ToByteArray());
}
}
public void SliceBuffer_CompleteWithEmptyPayload()
{
using (var sliceBuffer = SliceBufferSafeHandle.Create())
{
var destSpan = sliceBuffer.GetSpan(0);
Assert.IsTrue(destSpan.Length > 0); // some non-zero size memory is made available
sliceBuffer.Advance(0);
sliceBuffer.Complete();
CollectionAssert.AreEqual(new byte[0], sliceBuffer.ToByteArray());
Assert.AreEqual(1, sliceBuffer.TestOnly_GetSliceCount());
}
}
public void SliceBuffer_SizeHintZero()
{
using (var sliceBuffer = SliceBufferSafeHandle.Create())
{
var destSpan = sliceBuffer.GetSpan(0);
Assert.IsTrue(destSpan.Length > 0); // some non-zero size memory is made available
sliceBuffer.Reset();
var destMemory = sliceBuffer.GetMemory(0);
Assert.IsTrue(destMemory.Length > 0);
}
}
public void Complete_TruncateTailSpace()
{
using (var sliceBuffer = SliceBufferSafeHandle.Create())
{
var origPayload = GetTestBuffer(10);
var dest = sliceBuffer.GetSpan(origPayload.Length + 10);
origPayload.AsSpan().CopyTo(dest);
sliceBuffer.Advance(origPayload.Length);
// call complete where tail space needs to be truncated
sliceBuffer.Complete();
CollectionAssert.AreEqual(origPayload, sliceBuffer.ToByteArray());
}
}
public void SliceBuffer_BigPayload(int sizeHint)
{
using (var sliceBuffer = SliceBufferSafeHandle.Create())
{
var bigPayload = GetTestBuffer(4 * 1024 * 1024);
int offset = 0;
while (offset < bigPayload.Length)
{
var destSpan = sliceBuffer.GetSpan(sizeHint);
int copySize = Math.Min(destSpan.Length, bigPayload.Length - offset);
bigPayload.AsSpan(offset, copySize).CopyTo(destSpan);
sliceBuffer.Advance(copySize);
offset += copySize;
}
sliceBuffer.Complete();
CollectionAssert.AreEqual(bigPayload, sliceBuffer.ToByteArray());
}
}
public void SliceBufferIsReusable()
{
using (var sliceBuffer = SliceBufferSafeHandle.Create())
{
var origPayload = GetTestBuffer(10);
origPayload.AsSpan().CopyTo(sliceBuffer.GetSpan(origPayload.Length));
sliceBuffer.Advance(origPayload.Length);
sliceBuffer.Complete();
CollectionAssert.AreEqual(origPayload, sliceBuffer.ToByteArray());
sliceBuffer.Reset();
var origPayload2 = GetTestBuffer(20);
origPayload2.AsSpan().CopyTo(sliceBuffer.GetSpan(origPayload2.Length));
sliceBuffer.Advance(origPayload2.Length);
sliceBuffer.Complete();
CollectionAssert.AreEqual(origPayload2, sliceBuffer.ToByteArray());
sliceBuffer.Reset();
CollectionAssert.AreEqual(new byte[0], sliceBuffer.ToByteArray());
}
}
private void RunBody()
{
var completionRegistry = new CompletionRegistry(Environment, () => Environment.BatchContextPool.Lease(), () => throw new NotImplementedException());
var cq = CompletionQueueSafeHandle.CreateAsync(completionRegistry);
var call = CreateFakeCall(cq);
var sendCompletionCallback = new NopSendCompletionCallback();
var sliceBuffer = SliceBufferSafeHandle.Create();
var writeFlags = default(WriteFlags);
for (int i = 0; i < Iterations; i++)
{
// SendMessage steals the slices from the slice buffer, so we need to repopulate in each iteration.
sliceBuffer.Reset();
sliceBuffer.GetSpan(PayloadSize);
sliceBuffer.Advance(PayloadSize);
call.StartSendMessage(sendCompletionCallback, sliceBuffer, writeFlags, false);
var callback = completionRegistry.Extract(completionRegistry.LastRegisteredKey);
callback.OnComplete(true);
}
sliceBuffer.Dispose();
cq.Dispose();
}
public void StartSendStatusFromServer(ISendStatusFromServerCompletionCallback callback, Status status, MetadataArraySafeHandle metadataArray, bool sendEmptyInitialMetadata,
SliceBufferSafeHandle payload, WriteFlags writeFlags)
{
SendStatusFromServerCallback = callback;
}
public void StartSendMessage(ISendCompletionCallback callback, SliceBufferSafeHandle payload, WriteFlags writeFlags, bool sendEmptyInitialMetadata)
{
SendCompletionCallback = callback;
}
public void StartServerStreaming(IReceivedStatusOnClientCallback callback, SliceBufferSafeHandle payload, WriteFlags writeFlags, MetadataArraySafeHandle metadataArray, CallFlags callFlags)
{
StartCallMaybeFail();
ReceivedStatusOnClientCallback = callback;
}
public void StartUnary(BatchContextSafeHandle ctx, SliceBufferSafeHandle payload, WriteFlags writeFlags, MetadataArraySafeHandle metadataArray, CallFlags callFlags)
{
StartCallMaybeFail();
throw new NotImplementedException();
}
public void StartUnary(IUnaryResponseClientCallback callback, SliceBufferSafeHandle payload, WriteFlags writeFlags, MetadataArraySafeHandle metadataArray, CallFlags callFlags)
{
StartCallMaybeFail();
UnaryResponseClientCallback = callback;
}
