public void WriteCharArray_AcrossMultipleBuffers()
{
var bufferWriter = new TestMemoryBufferWriter(2);
var textWriter = new Utf8BufferTextWriter();
textWriter.SetWriter(bufferWriter);
var chars = "Hello world".ToCharArray();
textWriter.Write(chars);
textWriter.Flush();
var segments = bufferWriter.GetSegments();
Assert.Equal(6, segments.Count);
Assert.Equal(1, bufferWriter.Position);
Assert.Equal((byte)'H', segments[0].Span[0]);
Assert.Equal((byte)'e', segments[0].Span[1]);
Assert.Equal((byte)'l', segments[1].Span[0]);
Assert.Equal((byte)'l', segments[1].Span[1]);
Assert.Equal((byte)'o', segments[2].Span[0]);
Assert.Equal((byte)' ', segments[2].Span[1]);
Assert.Equal((byte)'w', segments[3].Span[0]);
Assert.Equal((byte)'o', segments[3].Span[1]);
Assert.Equal((byte)'r', segments[4].Span[0]);
Assert.Equal((byte)'l', segments[4].Span[1]);
Assert.Equal((byte)'d', segments[5].Span[0]);
}
public void WriteUnicodeStringAndCharsWithVaryingSegmentSizes(char singleChar, int segmentSize)
{
const string testString = "aいbろ";
const int iterations = 10;
var testBufferWriter = new TestMemoryBufferWriter(segmentSize);
var sb = new StringBuilder();
using (var textWriter = new Utf8BufferTextWriter())
{
textWriter.SetWriter(testBufferWriter);
for (int i = 0; i < iterations; i++)
{
textWriter.Write(singleChar);
textWriter.Write(testString);
textWriter.Write(singleChar);
sb.Append(singleChar);
sb.Append(testString);
sb.Append(singleChar);
}
}
var expected = sb.ToString();
var data = testBufferWriter.ToArray();
var result = Encoding.UTF8.GetString(data);
Assert.Equal(expected, result);
}
/// <summary>
/// Writes the serialized representation of a <see cref="HandshakeResponseMessage"/> to the specified writer.
/// </summary>
/// <param name="responseMessage">The message to write.</param>
/// <param name="output">The output writer.</param>
public static void WriteResponseMessage(HandshakeResponseMessage responseMessage, IBufferWriter <byte> output)
{
var textWriter = Utf8BufferTextWriter.Get(output);
try
{
using (var writer = JsonUtils.CreateJsonTextWriter(textWriter))
{
writer.WriteStartObject();
if (!string.IsNullOrEmpty(responseMessage.Error))
{
writer.WritePropertyName(ErrorPropertyName);
writer.WriteValue(responseMessage.Error);
}
writer.WritePropertyName(MinorVersionPropertyName);
writer.WriteValue(responseMessage.MinorVersion);
writer.WriteEndObject();
writer.Flush();
}
}
finally
{
Utf8BufferTextWriter.Return(textWriter);
}
TextMessageFormatter.WriteRecordSeparator(output);
}
public void WriteChar_SurrogatePairInMultipleCalls()
{
var fourCircles = char.ConvertFromUtf32(0x1F01C);
var chars = fourCircles.ToCharArray();
var bufferWriter = new TestMemoryBufferWriter(4096);
var textWriter = new Utf8BufferTextWriter();
textWriter.SetWriter(bufferWriter);
textWriter.Write(chars[0]);
textWriter.Flush();
// Surrogate buffered
Assert.Equal(0, bufferWriter.Position);
textWriter.Write(chars[1]);
textWriter.Flush();
Assert.Equal(4, bufferWriter.Position);
var expectedData = Encoding.UTF8.GetBytes(fourCircles);
var actualData = bufferWriter.CurrentSegment.Slice(0, 4).ToArray();
Assert.Equal(expectedData, actualData);
}
private void WriteMessageCore(HubMessage message, IBufferWriter <byte> stream)
{
var textWriter = Utf8BufferTextWriter.Get(stream);
try
{
using (var writer = JsonUtils.CreateJsonTextWriter(textWriter))
{
writer.WriteStartObject();
switch (message)
{
case InvocationMessage m:
WriteMessageType(writer, HubProtocolConstants.InvocationMessageType);
WriteHeaders(writer, m);
WriteInvocationMessage(m, writer);
break;
default:
throw new InvalidOperationException($"Unsupported message type: {message.GetType().FullName}");
}
writer.WriteEndObject();
writer.Flush();
}
}
finally
{
Utf8BufferTextWriter.Return(textWriter);
}
}
public static void WriteResponse(NegotiationResponse response, IBufferWriter <byte> output)
{
var textWriter = Utf8BufferTextWriter.Get(output);
try
{
using (var jsonWriter = JsonUtils.CreateJsonTextWriter(textWriter))
{
jsonWriter.WriteStartObject();
if (!string.IsNullOrEmpty(response.Url))
{
jsonWriter.WritePropertyName(UrlPropertyName);
jsonWriter.WriteValue(response.Url);
}
if (!string.IsNullOrEmpty(response.AccessToken))
{
jsonWriter.WritePropertyName(AccessTokenPropertyName);
jsonWriter.WriteValue(response.AccessToken);
}
if (!string.IsNullOrEmpty(response.ConnectionId))
{
jsonWriter.WritePropertyName(ConnectionIdPropertyName);
jsonWriter.WriteValue(response.ConnectionId);
}
jsonWriter.WritePropertyName(AvailableTransportsPropertyName);
jsonWriter.WriteStartArray();
foreach (var availableTransport in response.AvailableTransports)
{
jsonWriter.WriteStartObject();
jsonWriter.WritePropertyName(TransportPropertyName);
jsonWriter.WriteValue(availableTransport.Transport);
jsonWriter.WritePropertyName(TransferFormatsPropertyName);
jsonWriter.WriteStartArray();
foreach (var transferFormat in availableTransport.TransferFormats)
{
jsonWriter.WriteValue(transferFormat);
}
jsonWriter.WriteEndArray();
jsonWriter.WriteEndObject();
}
jsonWriter.WriteEndArray();
jsonWriter.WriteEndObject();
jsonWriter.Flush();
}
}
finally
{
Utf8BufferTextWriter.Return(textWriter);
}
}
public static void Return(Utf8BufferTextWriter writer)
{
_cachedInstance = writer;
writer._encoder.Reset();
writer._memory = Memory <byte> .Empty;
writer._memoryUsed = 0;
writer._bufferWriter = null;
#if DEBUG
writer._inUse = false;
#endif
}
public void WriteChar_UnicodeLastChar()
{
var bufferWriter = new TestMemoryBufferWriter(4096);
using (var textWriter = new Utf8BufferTextWriter())
{
textWriter.SetWriter(bufferWriter);
textWriter.Write('\u00A3');
}
Assert.Equal(2, bufferWriter.Position);
Assert.Equal((byte)0xC2, bufferWriter.CurrentSegment.Span[0]);
Assert.Equal((byte)0xA3, bufferWriter.CurrentSegment.Span[1]);
}
public void WriteCharArray_NonZeroStart()
{
var bufferWriter = new TestMemoryBufferWriter(4096);
var textWriter = new Utf8BufferTextWriter();
textWriter.SetWriter(bufferWriter);
var chars = "Hello world".ToCharArray();
textWriter.Write(chars, 6, 1);
textWriter.Flush();
Assert.Equal(1, bufferWriter.Position);
Assert.Equal((byte)'w', bufferWriter.CurrentSegment.Span[0]);
}
private void WriteMultiByteCharactersToSmallBuffers()
{
// Test string breakdown (char => UTF-8 hex values):
// a => 61
// い => E3-81-84
// b => 62
// ろ => E3-82-8D
// c => 63
// d => 64
// は => E3-81-AF
// に => E3-81-AB
// e => 65
// ほ => E3-81-BB
// f => 66
// へ => E3-81-B8
// ど => E3-81-A9
// g => 67
// h => 68
// i => 69
// \uD800\uDC00 => F0-90-80-80 (this is a surrogate pair that is represented as a single 4-byte UTF-8 encoding)
const string testString = "aいbろcdはにeほfへどghi\uD800\uDC00";
// By mixing single byte and multi-byte characters, we know that there will
// be spaces in the active segment that cannot fit the current character. This
// means we'll be testing the GetMemory(minimumSize) logic.
var bufferWriter = new TestMemoryBufferWriter(segmentSize: 5);
var writer = new Utf8BufferTextWriter();
writer.SetWriter(bufferWriter);
writer.Write(testString);
writer.Flush();
// Verify the output
var allSegments = bufferWriter.GetSegments().Select(s => s.ToArray()).ToArray();
Assert.Collection(allSegments,
seg => Assert.Equal(new byte[] { 0x61, 0xE3, 0x81, 0x84, 0x62 }, seg), // "aいb"
seg => Assert.Equal(new byte[] { 0xE3, 0x82, 0x8D, 0x63, 0x64 }, seg), // "ろcd"
seg => Assert.Equal(new byte[] { 0xE3, 0x81, 0xAF }, seg), // "は"
seg => Assert.Equal(new byte[] { 0xE3, 0x81, 0xAB, 0x65 }, seg), // "にe"
seg => Assert.Equal(new byte[] { 0xE3, 0x81, 0xBB, 0x66 }, seg), // "ほf"
seg => Assert.Equal(new byte[] { 0xE3, 0x81, 0xB8 }, seg), // "へ"
seg => Assert.Equal(new byte[] { 0xE3, 0x81, 0xA9, 0x67, 0x68 }, seg), // "どgh"
seg => Assert.Equal(new byte[] { 0x69, 0xF0, 0x90, 0x80, 0x80 }, seg)); // "i\uD800\uDC00"
Assert.Equal(testString, Encoding.UTF8.GetString(bufferWriter.ToArray()));
}
public void WriteChar_UnicodeAndRunOutOfBufferSpace()
{
var bufferWriter = new TestMemoryBufferWriter(4096);
var textWriter = new Utf8BufferTextWriter();
textWriter.SetWriter(bufferWriter);
textWriter.Write('[');
textWriter.Flush();
Assert.Equal(1, bufferWriter.Position);
Assert.Equal((byte)'[', bufferWriter.CurrentSegment.Span[0]);
textWriter.Write('"');
textWriter.Flush();
Assert.Equal(2, bufferWriter.Position);
Assert.Equal((byte)'"', bufferWriter.CurrentSegment.Span[1]);
for (var i = 0; i < 2000; i++)
{
textWriter.Write('\u00A3');
}
textWriter.Flush();
textWriter.Write('"');
textWriter.Flush();
Assert.Equal(4003, bufferWriter.Position);
Assert.Equal((byte)'"', bufferWriter.CurrentSegment.Span[4002]);
textWriter.Write(']');
textWriter.Flush();
Assert.Equal(4004, bufferWriter.Position);
var result = Encoding.UTF8.GetString(bufferWriter.CurrentSegment.Slice(0, bufferWriter.Position).ToArray());
Assert.Equal(2004, result.Length);
Assert.Equal('[', result[0]);
Assert.Equal('"', result[1]);
for (var i = 0; i < 2000; i++)
{
Assert.Equal('\u00A3', result[i + 2]);
}
Assert.Equal('"', result[2002]);
Assert.Equal(']', result[2003]);
}
public void WriteChar_Unicode()
{
var bufferWriter = new TestMemoryBufferWriter(4096);
var textWriter = new Utf8BufferTextWriter();
textWriter.SetWriter(bufferWriter);
textWriter.Write('[');
textWriter.Flush();
Assert.Equal(1, bufferWriter.Position);
Assert.Equal((byte)'[', bufferWriter.CurrentSegment.Span[0]);
textWriter.Write('"');
textWriter.Flush();
Assert.Equal(2, bufferWriter.Position);
Assert.Equal((byte)'"', bufferWriter.CurrentSegment.Span[1]);
textWriter.Write('\u00A3');
textWriter.Flush();
Assert.Equal(4, bufferWriter.Position);
textWriter.Write('\u00A3');
textWriter.Flush();
Assert.Equal(6, bufferWriter.Position);
textWriter.Write('"');
textWriter.Flush();
Assert.Equal(7, bufferWriter.Position);
Assert.Equal((byte)0xC2, bufferWriter.CurrentSegment.Span[2]);
Assert.Equal((byte)0xA3, bufferWriter.CurrentSegment.Span[3]);
Assert.Equal((byte)0xC2, bufferWriter.CurrentSegment.Span[4]);
Assert.Equal((byte)0xA3, bufferWriter.CurrentSegment.Span[5]);
Assert.Equal((byte)'"', bufferWriter.CurrentSegment.Span[6]);
textWriter.Write(']');
textWriter.Flush();
Assert.Equal(8, bufferWriter.Position);
Assert.Equal((byte)']', bufferWriter.CurrentSegment.Span[7]);
}
public static Utf8BufferTextWriter Get(IBufferWriter <byte> bufferWriter)
{
var writer = _cachedInstance;
if (writer == null)
{
writer = new Utf8BufferTextWriter();
}
// Taken off the thread static
_cachedInstance = null;
#if DEBUG
if (writer._inUse)
{
throw new InvalidOperationException("The writer wasn't returned!");
}
writer._inUse = true;
#endif
writer.SetWriter(bufferWriter);
return(writer);
}
public void GetAndReturnCachedBufferTextWriter()
{
var bufferWriter1 = new TestMemoryBufferWriter();
var textWriter1 = Utf8BufferTextWriter.Get(bufferWriter1);
textWriter1.Write("Hello");
textWriter1.Flush();
Utf8BufferTextWriter.Return(textWriter1);
Assert.Equal("Hello", Encoding.UTF8.GetString(bufferWriter1.ToArray()));
var bufferWriter2 = new TestMemoryBufferWriter();
var textWriter2 = Utf8BufferTextWriter.Get(bufferWriter2);
textWriter2.Write("World");
textWriter2.Flush();
Utf8BufferTextWriter.Return(textWriter2);
Assert.Equal("World", Encoding.UTF8.GetString(bufferWriter2.ToArray()));
Assert.Same(textWriter1, textWriter2);
}
/// <summary>
/// Writes the serialized representation of a <see cref="HandshakeRequestMessage"/> to the specified writer.
/// </summary>
/// <param name="requestMessage">The message to write.</param>
/// <param name="output">The output writer.</param>
public static void WriteRequestMessage(HandshakeRequestMessage requestMessage, IBufferWriter <byte> output)
{
var textWriter = Utf8BufferTextWriter.Get(output);
try
{
using (var writer = JsonUtils.CreateJsonTextWriter(textWriter))
{
writer.WriteStartObject();
writer.WritePropertyName(ProtocolPropertyName);
writer.WriteValue(requestMessage.Protocol);
writer.WritePropertyName(ProtocolVersionPropertyName);
writer.WriteValue(requestMessage.Version);
writer.WriteEndObject();
writer.Flush();
}
}
finally
{
Utf8BufferTextWriter.Return(textWriter);
}
TextMessageFormatter.WriteRecordSeparator(output);
}
