public void With_WebSocket_CanReadTwoBufferedSmallFrames()
{
var handshake = GenerateSimpleHandshake();
using (var ms = new MemoryStream())
using (WebSocket ws = new WebSocketRfc6455(ms, new WebSocketListenerOptions()
{
PingTimeout = Timeout.InfiniteTimeSpan
}, new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1), new IPEndPoint(IPAddress.Parse("127.0.0.1"), 2), handshake.Request, handshake.Response, handshake.NegotiatedMessageExtensions))
{
ms.Write(new Byte[] { 129, 130, 75, 91, 80, 26, 3, 50 }, 0, 8);
ms.Write(new Byte[] { 129, 130, 75, 91, 80, 26, 3, 50 }, 0, 8);
ms.Flush();
ms.Seek(0, SeekOrigin.Begin);
var reader = ws.ReadMessageAsync(CancellationToken.None).Result;
Assert.IsNotNull(reader);
using (var sr = new StreamReader(reader, Encoding.UTF8, true, 1024, true))
{
String s = sr.ReadToEnd();
Assert.AreEqual("Hi", s);
}
reader = ws.ReadMessageAsync(CancellationToken.None).Result;
Assert.IsNotNull(reader);
using (var sr = new StreamReader(reader, Encoding.UTF8, true, 1024, true))
{
String s = sr.ReadToEndAsync().Result;
Assert.AreEqual("Hi", s);
}
reader = ws.ReadMessageAsync(CancellationToken.None).Result;
Assert.IsNull(reader);
}
}
public void With_WebSocket_FailsWithDoubleMessageRead()
{
Assert.Throws <WebSocketException>(() =>
{
var handshake = GenerateSimpleHandshake();
using (var ms = new MemoryStream())
using (
WebSocket ws = new WebSocketRfc6455(ms,
new WebSocketListenerOptions()
{
PingTimeout = Timeout.InfiniteTimeSpan
},
new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1), new IPEndPoint(IPAddress.Parse("127.0.0.1"), 2),
handshake.Request, handshake.Response, handshake.NegotiatedMessageExtensions))
{
ms.Write(new Byte[] { 129, 130, 75, 91, 80, 26, 3, 50 }, 0, 8);
ms.Write(new Byte[] { 129, 130, 75, 91, 80, 26, 3, 50 }, 0, 8);
ms.Flush();
ms.Seek(0, SeekOrigin.Begin);
var reader = ws.ReadMessage();
reader = ws.ReadMessage();
}
});
}
public void ReadEmptyMessage()
{
var handshake = this.GenerateSimpleHandshake();
using (var connectionInput = new MemoryStream())
using (var connectionOutput = new MemoryStream())
using (var connection = new DummyNetworkConnection(connectionInput, connectionOutput))
using (var ws = new WebSocketRfc6455(connection, this.options, handshake.Request, handshake.Response, handshake.NegotiatedMessageExtensions))
{
connectionInput.Write(new byte[]
{
129, 128, 166, 124, 106, 65
}, 0, 6);
connectionInput.Flush();
connectionInput.Seek(0, SeekOrigin.Begin);
var reader = ws.ReadMessageAsync(CancellationToken.None).Result;
Assert.NotNull(reader);
using (var sr = new StreamReader(reader, Encoding.UTF8, true, 1024, true))
{
var s = sr.ReadToEnd();
Assert.Equal(string.Empty, s);
}
}
}
public void With_WebSocket_CanWriteStringAsync()
{
var factories = new WebSocketFactoryCollection();
factories.RegisterStandard(new WebSocketFactoryRfc6455());
CancellationToken cancellationToken = CancellationToken.None;
string msg = "01";
var handshake = GenerateSimpleHandshake(factories);
var ms = new MemoryStream();
using (WebSocket ws = new WebSocketRfc6455(
ms,
new WebSocketListenerOptions {
PingTimeout = Timeout.InfiniteTimeSpan
},
new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1),
new IPEndPoint(IPAddress.Parse("127.0.0.1"), 2),
handshake.Request,
handshake.Response,
handshake.NegotiatedMessageExtensions))
{
ws.WriteStringAsync(msg, cancellationToken).Wait(cancellationToken);
}
Assert.Equal(new byte[] { 1, 2, 48, 49, 128, 0, 136, 2, 3, 232 }, ms.ToArray());
}
public void ReadTwoBufferedSmallFrames()
{
var handshake = this.GenerateSimpleHandshake();
using (var connectionInput = new MemoryStream())
using (var connectionOutput = new MemoryStream())
using (var connection = new DummyNetworkConnection(connectionInput, connectionOutput))
using (var ws = new WebSocketRfc6455(connection, this.options, handshake.Request, handshake.Response, handshake.NegotiatedMessageExtensions))
{
connectionInput.Write(new byte[] { 129, 130, 75, 91, 80, 26, 3, 50 }, 0, 8);
connectionInput.Write(new byte[] { 129, 130, 75, 91, 80, 26, 3, 50 }, 0, 8);
connectionInput.Flush();
connectionInput.Seek(0, SeekOrigin.Begin);
var reader = ws.ReadMessageAsync(CancellationToken.None).Result;
Assert.NotNull(reader);
using (var sr = new StreamReader(reader, Encoding.UTF8, true, 1024, true))
{
var s = sr.ReadToEnd();
Assert.Equal("Hi", s);
}
reader = ws.ReadMessageAsync(CancellationToken.None).Result;
Assert.NotNull(reader);
using (var sr = new StreamReader(reader, Encoding.UTF8, true, 1024, true))
{
var s = sr.ReadToEndAsync().Result;
Assert.Equal("Hi", s);
}
reader = ws.ReadMessageAsync(CancellationToken.None).Result;
Assert.Null(reader);
}
}
//[ExpectedException(typeof(WebSocketException))]
public void With_WebSocket_FailsWithDoubleMessageAwait()
{
var handshake = GenerateSimpleHandshake();
try
{
using (var ms = new BufferedStream(new MemoryStream()))
using (
WebSocket ws = new WebSocketRfc6455(ms,
new WebSocketListenerOptions()
{
PingTimeout = Timeout.InfiniteTimeSpan
},
new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1), new IPEndPoint(IPAddress.Parse("127.0.0.1"), 2),
handshake.Request, handshake.Response, handshake.NegotiatedMessageExtensions))
{
ms.Write(new Byte[] { 129, 130, 75, 91, 80, 26, 3, 50 }, 0, 8);
ms.Write(new Byte[] { 129, 130, 75, 91, 80, 26, 3, 50 }, 0, 8);
ms.Flush();
ms.Seek(0, SeekOrigin.Begin);
ws.ReadMessage();
ws.ReadMessage();
}
}
catch (WebSocketException)
{
}
catch (Exception)
{
Assert.Fail("Should throw WebSocketException");
}
}
public void WriteTwoSequentialMessages()
{
var handshake = this.GenerateSimpleHandshake();
using (var connectionInput = new MemoryStream())
using (var connectionOutput = new MemoryStream())
using (var connection = new DummyNetworkConnection(connectionInput, connectionOutput))
using (var ws = new WebSocketRfc6455(connection, this.options, handshake.Request, handshake.Response, handshake.NegotiatedMessageExtensions))
{
using (var writer = ws.CreateMessageWriter(WebSocketMessageType.Text)) { }
using (var writer = ws.CreateMessageWriter(WebSocketMessageType.Text)) { }
}
}
public void With_WebSocket_CanWriteTwoSequentialMessages()
{
var handshake = GenerateSimpleHandshake();
using (var ms = new MemoryStream())
using (WebSocket ws = new WebSocketRfc6455(ms, new WebSocketListenerOptions()
{
PingTimeout = Timeout.InfiniteTimeSpan
}, new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1), new IPEndPoint(IPAddress.Parse("127.0.0.1"), 2), handshake.Request, handshake.Response, handshake.NegotiatedMessageExtensions))
{
using (var writer = ws.CreateMessageWriter(WebSocketMessageType.Text)) { }
using (var writer = ws.CreateMessageWriter(WebSocketMessageType.Text)) { }
}
}
public void With_WebSocket_CanWriteString()
{
string msg = "01";
var handshake = GenerateSimpleHandshake();
var ms = new MemoryStream();
using (WebSocket ws = new WebSocketRfc6455(ms, new WebSocketListenerOptions {
PingTimeout = Timeout.InfiniteTimeSpan
}, new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1), new IPEndPoint(IPAddress.Parse("127.0.0.1"), 2), handshake.Request, handshake.Response, handshake.NegotiatedMessageExtensions))
{
ws.WriteString(msg);
}
Assert.AreEqual(new byte[] { 129, 2, 48, 49, 136, 2, 3, 232 }, ms.ToArray());
}
public void With_WebSocket_CanDetectHalfOpenConnection()
{
var handshake = GenerateSimpleHandshake();
using (var ms = new MemoryStream())
using (WebSocket ws = new WebSocketRfc6455(ms, new WebSocketListenerOptions()
{
PingTimeout = TimeSpan.FromMilliseconds(100)
}, new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1), new IPEndPoint(IPAddress.Parse("127.0.0.1"), 2), handshake.Request, handshake.Response, handshake.NegotiatedMessageExtensions))
{
ws.ReadMessageAsync(CancellationToken.None);
// DateTime has no millisecond precission.
Thread.Sleep(500);
Assert.IsFalse(ws.IsConnected);
}
}
public void FailDoubleMessageWrite()
{
var handshake = this.GenerateSimpleHandshake();
Assert.Throws <WebSocketException>(() =>
{
using (var connectionInput = new MemoryStream())
using (var connectionOutput = new MemoryStream())
using (var connection = new DummyNetworkConnection(connectionInput, connectionOutput))
using (var ws = new WebSocketRfc6455(connection, this.options, handshake.Request, handshake.Response, handshake.NegotiatedMessageExtensions))
{
var writer = ws.CreateMessageWriter(WebSocketMessageType.Text);
writer = ws.CreateMessageWriter(WebSocketMessageType.Text);
}
});
}
public static void With_WebSocket_CanWriteString()
{
string msg = "01";
var handshake = GenerateSimpleHandshake();
var ms = new MemoryStream();
using (WebSocket ws = new WebSocketRfc6455(ms, new WebSocketListenerOptions {
PingTimeout = Timeout.InfiniteTimeSpan
}, new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1), new IPEndPoint(IPAddress.Parse("127.0.0.1"), 2), handshake.Request, handshake.Response, handshake.NegotiatedMessageExtensions))
{
ws.WriteString(msg);
}
Console.WriteLine("Should be : 129, 2, 48, 49, 136, 2, 3, 232");
byte[] result = ms.ToArray();
Console.Write("Result : " + string.Join(", ", result.Select(x => x.ToString())));
Console.WriteLine();
}
public async Task With_WebSocket_FailsWithDoubleMessageAwait()
{
var handshake = GenerateSimpleHandshake();
using (var ms = new BufferedStream(new MemoryStream()))
using (WebSocket ws = new WebSocketRfc6455(ms, new WebSocketListenerOptions()
{
PingTimeout = Timeout.InfiniteTimeSpan
}, new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1), new IPEndPoint(IPAddress.Parse("127.0.0.1"), 2), handshake.Request, handshake.Response, handshake.NegotiatedMessageExtensions))
{
ms.Write(new Byte[] { 129, 130, 75, 91, 80, 26, 3, 50 }, 0, 8);
ms.Write(new Byte[] { 129, 130, 75, 91, 80, 26, 3, 50 }, 0, 8);
ms.Flush();
ms.Seek(0, SeekOrigin.Begin);
await ws.ReadMessageAsync(CancellationToken.None);
await ws.ReadMessageAsync(CancellationToken.None);
}
}
public void With_WebSocket_FailsWithDoubleMessageWrite()
{
Assert.Throws <WebSocketException>(() =>
{
var handshake = GenerateSimpleHandshake();
using (var ms = new MemoryStream())
using (
WebSocket ws = new WebSocketRfc6455(ms,
new WebSocketListenerOptions()
{
PingTimeout = Timeout.InfiniteTimeSpan
},
new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1), new IPEndPoint(IPAddress.Parse("127.0.0.1"), 2),
handshake.Request, handshake.Response, handshake.NegotiatedMessageExtensions))
{
var writer = ws.CreateMessageWriter(WebSocketMessageType.Text);
writer = ws.CreateMessageWriter(WebSocketMessageType.Text);
}
});
}
public void DetectHalfOpenConnection()
{
var handshake = this.GenerateSimpleHandshake();
var options = this.options.Clone();
options.PingTimeout = TimeSpan.FromMilliseconds(100);
using (var connectionInput = new MemoryStream())
using (var connectionOutput = new MemoryStream())
using (var connection = new DummyNetworkConnection(connectionInput, connectionOutput))
using (var ws = new WebSocketRfc6455(connection, options, handshake.Request,
handshake.Response, handshake.NegotiatedMessageExtensions))
{
ws.ReadMessageAsync(CancellationToken.None);
// DateTime has no millisecond precision.
Thread.Sleep(500);
Assert.False(ws.IsConnected);
}
}
public async Task FailDoubleMessageAwait()
{
var handshake = this.GenerateSimpleHandshake();
await Assert.ThrowsAsync <WebSocketException>(async() =>
{
using (var connectionInput = new BufferedStream(new MemoryStream()))
using (var connectionOutput = new MemoryStream())
using (var connection = new DummyNetworkConnection(connectionInput, connectionOutput))
using (var ws = new WebSocketRfc6455(connection, this.options, handshake.Request, handshake.Response, handshake.NegotiatedMessageExtensions))
{
connectionInput.Write(new byte[] { 129, 130, 75, 91, 80, 26, 3, 50 }, 0, 8);
connectionInput.Write(new byte[] { 129, 130, 75, 91, 80, 26, 3, 50 }, 0, 8);
connectionInput.Flush();
connectionInput.Seek(0, SeekOrigin.Begin);
await ws.ReadMessageAsync(CancellationToken.None).ConfigureAwait(false);
await ws.ReadMessageAsync(CancellationToken.None).ConfigureAwait(false);
}
}).ConfigureAwait(false);
}
