public void WriteMultipleMessages()
{
var expectedEncoding = new byte[]
{
/* length: */ 0x00,
/* body: <empty> */
/* length: */ 0x0E,
/* body: */ 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x2C, 0x0D, 0x0A, 0x57, 0x6F, 0x72, 0x6C, 0x64, 0x21,
};
var messages = new[]
{
new byte[0],
Encoding.UTF8.GetBytes("Hello,\r\nWorld!")
};
var output = new MemoryStream(); // Use small chunks to test Advance/Enlarge and partial payload writing
foreach (var message in messages)
{
BinaryMessageFormatter.WriteLengthPrefix(message.Length, output);
output.Write(message, 0, message.Length);
}
Assert.Equal(expectedEncoding, output.ToArray());
}
public void WriteMultipleMessages()
{
var expectedEncoding = new byte[]
{
/* length: */ 0x00,
/* body: <empty> */
/* length: */ 0x0E,
/* body: */ 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x2C, 0x0D, 0x0A, 0x57, 0x6F, 0x72, 0x6C, 0x64, 0x21,
};
var messages = new[]
{
new byte[0],
Encoding.UTF8.GetBytes("Hello,\r\nWorld!")
};
var writer = MemoryBufferWriter.Get(); // Use small chunks to test Advance/Enlarge and partial payload writing
try
{
foreach (var message in messages)
{
BinaryMessageFormatter.WriteLengthPrefix(message.Length, writer);
writer.Write(message);
}
Assert.Equal(expectedEncoding, writer.ToArray());
}
finally
{
MemoryBufferWriter.Return(writer);
}
}
/// <inheritdoc />
public ReadOnlyMemory <byte> GetMessageBytes(HubMessage message)
{
var memoryBufferWriter = MemoryBufferWriter.Get();
try
{
var writer = new MessagePackWriter(memoryBufferWriter);
// Write message to a buffer so we can get its length
WriteMessageCore(message, ref writer);
var dataLength = memoryBufferWriter.Length;
var prefixLength = BinaryMessageFormatter.LengthPrefixLength(memoryBufferWriter.Length);
var array = new byte[dataLength + prefixLength];
var span = array.AsSpan();
// Write length then message to output
var written = BinaryMessageFormatter.WriteLengthPrefix(memoryBufferWriter.Length, span);
Debug.Assert(written == prefixLength);
memoryBufferWriter.CopyTo(span.Slice(prefixLength));
return(array);
}
finally
{
MemoryBufferWriter.Return(memoryBufferWriter);
}
}
public void Setup()
{
var buffer = new byte[MessageLength];
Random.Shared.NextBytes(buffer);
var writer = MemoryBufferWriter.Get();
try
{
BinaryMessageFormatter.WriteLengthPrefix(buffer.Length, writer);
writer.Write(buffer);
_binaryInput = writer.ToArray();
}
finally
{
MemoryBufferWriter.Return(writer);
}
buffer = new byte[MessageLength];
Random.Shared.NextBytes(buffer);
writer = MemoryBufferWriter.Get();
try
{
writer.Write(buffer);
TextMessageFormatter.WriteRecordSeparator(writer);
_textInput = writer.ToArray();
}
finally
{
MemoryBufferWriter.Return(writer);
}
}
public void WriteBinaryMessage(byte[] encoded, byte[] payload)
{
using (var writer = new MemoryBufferWriter())
{
BinaryMessageFormatter.WriteLengthPrefix(payload.Length, writer);
writer.Write(payload);
Assert.Equal(encoded, writer.ToArray());
}
}
public void RoundTrippingTest(byte[] payload)
{
using (var ms = new MemoryStream())
{
BinaryMessageFormatter.WriteLengthPrefix(payload.Length, ms);
ms.Write(payload, 0, payload.Length);
var buffer = new ReadOnlyMemory <byte>(ms.ToArray());
Assert.True(BinaryMessageParser.TryParseMessage(ref buffer, out var roundtripped));
Assert.Equal(payload, roundtripped.ToArray());
}
}
public void RoundTrippingTest(byte[] payload)
{
using (var writer = new MemoryBufferWriter())
{
BinaryMessageFormatter.WriteLengthPrefix(payload.Length, writer);
writer.Write(payload);
var buffer = new ReadOnlySequence <byte>(writer.ToArray());
Assert.True(BinaryMessageParser.TryParseMessage(ref buffer, out var roundtripped));
Assert.Equal(payload, roundtripped.ToArray());
}
}
public void WriteTextMessage(byte[] encoded, string payload)
{
var message = Encoding.UTF8.GetBytes(payload);
using (var writer = new MemoryBufferWriter())
{
BinaryMessageFormatter.WriteLengthPrefix(message.Length, writer);
writer.Write(message);
Assert.Equal(encoded, writer.ToArray());
}
}
public void WriteMessage(HubMessage message, IBufferWriter <byte> output)
{
using (var stream = new LimitArrayPoolWriteStream())
{
// Write message to a buffer so we can get its length
WriteMessageCore(message, stream);
var buffer = stream.GetBuffer();
// Write length then message to output
BinaryMessageFormatter.WriteLengthPrefix(buffer.Count, output);
output.Write(buffer);
}
}
public void WriteBinaryMessage(int offset, byte[] encoded, byte[] payload)
{
var output = new MemoryStream();
if (offset > 0)
{
output.Seek(offset, SeekOrigin.Begin);
}
BinaryMessageFormatter.WriteLengthPrefix(payload.Length, output);
output.Write(payload, 0, payload.Length);
Assert.Equal(encoded, output.ToArray().Skip(offset));
}
private static byte[] Frame(byte[] input)
{
var stream = MemoryBufferWriter.Get();
try
{
BinaryMessageFormatter.WriteLengthPrefix(input.Length, stream);
stream.Write(input);
return stream.ToArray();
}
finally
{
MemoryBufferWriter.Return(stream);
}
}
public void WriteTextMessage(int offset, byte[] encoded, string payload)
{
var message = Encoding.UTF8.GetBytes(payload);
var output = new MemoryStream();
if (offset > 0)
{
output.Seek(offset, SeekOrigin.Begin);
}
BinaryMessageFormatter.WriteLengthPrefix(message.Length, output);
output.Write(message, 0, message.Length);
Assert.Equal(encoded, output.ToArray().Skip(offset));
}
public void WriteBinaryMessage(byte[] encoded, byte[] payload)
{
var writer = MemoryBufferWriter.Get();
try
{
BinaryMessageFormatter.WriteLengthPrefix(payload.Length, writer);
writer.Write(payload);
Assert.Equal(encoded, writer.ToArray());
}
finally
{
MemoryBufferWriter.Return(writer);
}
}
public void WriteTextMessage(byte[] encoded, string payload)
{
var message = Encoding.UTF8.GetBytes(payload);
var writer = MemoryBufferWriter.Get();
try
{
BinaryMessageFormatter.WriteLengthPrefix(message.Length, writer);
writer.Write(message);
Assert.Equal(encoded, writer.ToArray());
}
finally
{
MemoryBufferWriter.Return(writer);
}
}
public void WriteMessage(HubMessage message, IBufferWriter <byte> output)
{
var writer = MemoryBufferWriter.Get();
try
{
// Write message to a buffer so we can get its length
WriteMessageCore(message, writer);
// Write length then message to output
BinaryMessageFormatter.WriteLengthPrefix(writer.Length, output);
writer.CopyTo(output);
}
finally
{
MemoryBufferWriter.Return(writer);
}
}
public void WriteMessage(HubMessage message, Stream output)
{
// We're writing data into the memoryStream so that we can get the length prefix
using (var memoryStream = new MemoryStream())
{
WriteMessageCore(message, memoryStream);
if (memoryStream.TryGetBuffer(out var buffer))
{
// Write the buffer directly
BinaryMessageFormatter.WriteLengthPrefix(buffer.Count, output);
output.Write(buffer.Array, buffer.Offset, buffer.Count);
}
else
{
BinaryMessageFormatter.WriteLengthPrefix(memoryStream.Length, output);
memoryStream.Position = 0;
memoryStream.CopyTo(output);
}
}
}
public void Setup()
{
var buffer = new byte[MessageLength];
Random.NextBytes(buffer);
var output = new MemoryStream();
BinaryMessageFormatter.WriteLengthPrefix(buffer.Length, output);
output.Write(buffer, 0, buffer.Length);
_binaryInput = output.ToArray();
buffer = new byte[MessageLength];
Random.NextBytes(buffer);
output = new MemoryStream();
output.Write(buffer, 0, buffer.Length);
TextMessageFormatter.WriteRecordSeparator(output);
_textInput = output.ToArray();
}
public void Setup()
{
var buffer = new byte[MessageLength];
Random.NextBytes(buffer);
using (var writer = new MemoryBufferWriter())
{
BinaryMessageFormatter.WriteLengthPrefix(buffer.Length, writer);
writer.Write(buffer);
_binaryInput = writer.ToArray();
}
buffer = new byte[MessageLength];
Random.NextBytes(buffer);
using (var writer = new MemoryBufferWriter())
{
writer.Write(buffer);
TextMessageFormatter.WriteRecordSeparator(writer);
_textInput = writer.ToArray();
}
}
///// <inheritdoc />
public ReadOnlyMemory <byte> GetMessageBytes(HubMessage message)
{
using var writer = new ArrayBufferWriter <byte>();
// Write message to a buffer so we can get its length
WriteMessageCore(message, writer);
var memory = writer.WrittenMemory;
var dataLength = memory.Length;
var prefixLength = BinaryMessageFormatter.LengthPrefixLength(dataLength);
var array = new byte[dataLength + prefixLength];
var span = array.AsSpan();
// Write length then message to output
var written = BinaryMessageFormatter.WriteLengthPrefix(dataLength, span);
Debug.Assert(written == prefixLength);
memory.Span.CopyTo(span.Slice(prefixLength));
return(array);
}
