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()); }