public void GetSpan_WriteWithHint0()
{
var prefixWriter = new PrefixingBufferWriter <byte>(this.sequence, Prefix.Length, 0);
var span = prefixWriter.GetSpan(0);
Assert.NotEqual(0, span.Length);
}
public void SomePayload(
bool largArrayPool,
bool excessSpan,
[CombinatorialValues(0, PayloadSize - 1, PayloadSize, PayloadSize + 1)] int sizeHint,
[CombinatorialValues(1, 2, 3, PayloadSize)] int stepCount)
{
this.mockPool.MinArraySizeFactor = largArrayPool ? 2.0 : 1.0;
var prefixWriter = new PrefixingBufferWriter <byte>(this.sequence, Prefix.Length, sizeHint);
int stepSize = Payload.Length / stepCount;
int expectedLength = 0;
for (int i = 0; i < stepCount - 1; i++)
{
var spanToWrite = Payload.Span.Slice(stepSize * i, stepSize);
if (excessSpan)
{
var targetSpan = prefixWriter.GetSpan((int)(spanToWrite.Length * 1.5));
spanToWrite.CopyTo(targetSpan);
prefixWriter.Advance(spanToWrite.Length);
}
else
{
prefixWriter.Write(spanToWrite);
}
expectedLength += spanToWrite.Length;
Assert.Equal(expectedLength, prefixWriter.Length);
}
// The last step fills in the remainder as well.
prefixWriter.Write(Payload.Span.Slice(stepSize * (stepCount - 1)));
this.PayloadCompleteHelper(prefixWriter);
}
public void GetSpan_WriteFillThenRequest0()
{
var prefixWriter = new PrefixingBufferWriter <byte>(this.sequence, Prefix.Length, 0);
var span = prefixWriter.GetSpan(5);
prefixWriter.Advance(span.Length);
span = prefixWriter.GetSpan(0);
Assert.NotEqual(0, span.Length);
}
public void NoPayload()
{
var prefixWriter = new PrefixingBufferWriter <byte>(this.sequence, Prefix.Length, 50);
Assert.Equal(0, this.sequence.Length);
Prefix.CopyTo(prefixWriter.Prefix);
prefixWriter.Commit();
Assert.Equal(Prefix.Length, this.sequence.Length);
Assert.Equal(Prefix.ToArray(), this.sequence.AsReadOnlySequence.ToArray());
}
public void GetMemory()
{
var prefixWriter = new PrefixingBufferWriter <byte>(this.sequence, Prefix.Length, 0);
var mem = prefixWriter.GetMemory(Payload.Length);
Assert.NotEqual(0, mem.Length);
Payload.CopyTo(mem);
prefixWriter.Advance(Payload.Length);
this.PayloadCompleteHelper(prefixWriter);
}
/// <inheritdoc/>
protected override void Write(JsonRpcMessage content, CancellationToken cancellationToken)
{
if (this.prefixingWriter == null)
{
this.prefixingWriter = new PrefixingBufferWriter <byte>(this.Writer, sizeof(int));
}
// Write out the actual message content, counting all written bytes.
this.formatter.Serialize(this.prefixingWriter, content);
// Now go back and fill in the header with the actual content length.
Utilities.Write(this.prefixingWriter.Prefix.Span, checked ((int)this.prefixingWriter.Length));
this.prefixingWriter.Commit();
}
public void ReuseAfterComplete()
{
var prefixWriter = new PrefixingBufferWriter <byte>(this.sequence, Prefix.Length, 0);
prefixWriter.Write(Payload.Span);
Assert.Equal(Payload.Length, prefixWriter.Length);
this.PayloadCompleteHelper(prefixWriter);
this.sequence.Reset();
Assert.Equal(0, prefixWriter.Length);
prefixWriter.Write(Payload.Span);
Assert.Equal(Payload.Length, prefixWriter.Length);
this.PayloadCompleteHelper(prefixWriter);
}
private void PayloadCompleteHelper(PrefixingBufferWriter <byte> prefixWriter)
{
// There mustn't be any calls to Advance on the underlying buffer yet, or else we've lost the opportunity to write the prefix.
Assert.Equal(0, this.sequence.Length);
var length = prefixWriter.Length;
// Go ahead and commit everything, with our prefix.
Prefix.CopyTo(prefixWriter.Prefix);
prefixWriter.Commit();
Assert.Equal(length + Prefix.Length, this.sequence.Length);
// Verify that the prefix immediately precedes the payload.
Assert.Equal(Prefix.ToArray().Concat(Payload.ToArray()), this.sequence.AsReadOnlySequence.ToArray());
}
