|
private ReadAsync ( |
||
| cancellationToken | ||
| return | Task |
|
public void PayloadTest()
{
AsyncPump.Run(
async() =>
{
#pragma warning disable SA1123 // Do not place regions within elements. Necessary so that tested code snippets can be included in the documentation.
#region Payload Test
var writtenMessage = new S101Message(0x00, new EmberData(0x01, 0x0A, 0x02));
var writtenPayload = new byte[8192];
this.Random.NextBytes(writtenPayload);
using (var encodedStream = new MemoryStream())
{
// First we create a writer, which can be used to write multiple messages.
// We specify which methods are used to write encoded output and flush it plus the size the internal
// buffer should have.
var writer = new S101Writer(encodedStream.WriteAsync);
// Next we write the message. In return we get a Stream object for the payload.
using (var payloadStream =
await writer.WriteMessageAsync(writtenMessage, CancellationToken.None))
{
// Now we write the payload.
await payloadStream.WriteAsync(writtenPayload, 0, writtenPayload.Length);
await payloadStream.DisposeAsync(CancellationToken.None);
}
await writer.DisposeAsync(CancellationToken.None);
// Reset the encoded stream to the beginning, so that we can read from it.
encodedStream.Position = 0;
// First we create a reader, which can be used to read multiple messages.
// We specify which methods are used to read encoded input.
var reader = new S101Reader(encodedStream.ReadAsync);
Assert.IsTrue(await reader.ReadAsync(CancellationToken.None)); // Read the first message
var readMessage = reader.Message;
// Assert the written and read messages are equal
Assert.AreEqual(writtenMessage.Slot, readMessage.Slot);
Assert.AreEqual(writtenMessage.Command, readMessage.Command);
using (var readPayload = new MemoryStream())
{
await reader.Payload.CopyToAsync(readPayload); // Copy the payload.
// Assert that there is only one message
Assert.IsFalse(await reader.ReadAsync(CancellationToken.None));
CollectionAssert.AreEqual(writtenPayload, readPayload.ToArray());
}
await reader.DisposeAsync(CancellationToken.None);
}
#endregion
#pragma warning restore SA1123 // Do not place regions within elements
});
}
public void MainTest()
{
AsyncPump.Run(
async() =>
{
var writtenBytes = new byte[this.Random.Next(3072, 10241)];
this.Random.NextBytes(writtenBytes);
using (var output = new MemoryStream())
{
using (var framer = new GlowOutput(1024, 0, (s, e) => output.Write(e.FramedPackage, 0, e.FramedPackageLength)))
{
framer.WriteBytes(writtenBytes);
framer.Finish();
}
output.Position = 0;
var reader = new S101Reader(output.ReadAsync, 1024);
Assert.IsTrue(await reader.ReadAsync(CancellationToken.None));
Assert.IsInstanceOfType(reader.Message.Command, typeof(EmberData));
using (var input = new MemoryStream())
{
await reader.Payload.CopyToAsync(input);
CollectionAssert.AreEqual(writtenBytes, input.ToArray());
}
await reader.DisposeAsync(CancellationToken.None);
}
});
}
public void MainTest()
{
AsyncPump.Run(
async () =>
{
var writtenBytes = new byte[this.Random.Next(3072, 10241)];
this.Random.NextBytes(writtenBytes);
using (var output = new MemoryStream())
{
using (var framer = new GlowOutput(1024, 0, (s, e) => output.Write(e.FramedPackage, 0, e.FramedPackageLength)))
{
framer.WriteBytes(writtenBytes);
framer.Finish();
}
output.Position = 0;
var reader = new S101Reader(output.ReadAsync, 1024);
Assert.IsTrue(await reader.ReadAsync(CancellationToken.None));
Assert.IsInstanceOfType(reader.Message.Command, typeof(EmberData));
using (var input = new MemoryStream())
{
await reader.Payload.CopyToAsync(input);
CollectionAssert.AreEqual(writtenBytes, input.ToArray());
}
await reader.DisposeAsync(CancellationToken.None);
}
});
}
private static async Task TestS101ReaderAsync(byte[] message, int messageCount)
{
byte[] buffer = new byte[BlockSize];
using (var stream = new MemoryStream(message))
{
var reader = new S101Reader(stream.ReadAsync, 1024);
for (int index = 0; index < messageCount; ++index)
{
await reader.ReadAsync(CancellationToken.None);
using (var payload = reader.Payload)
{
await payload.ReadAsync(buffer, 0, buffer.Length);
await payload.DisposeAsync(CancellationToken.None);
}
stream.Position = 0;
}
await reader.DisposeAsync(CancellationToken.None);
}
}
private async Task <bool> ReadWithTimeoutAsync(
IDisposable connection, S101Reader reader, Task cancellationFailed)
{
int timeoutCount = 0;
var timeoutHalf = this.timeout >= 0 ? this.timeout / 2 : this.timeout;
var readTask = reader.ReadAsync(this.source.Token);
Task timeoutTask;
// In a perfect world, the cancellationFailed business would not be necessary, because readTask should
// complete immediately when a cancellation is requested. In the real world however, such "rarely" used
// classes as NetworkStream do not support cancellation, see
// http://stackoverflow.com/questions/12421989/networkstream-readasync-with-a-cancellation-token-never-cancels
while (
await Task.WhenAny(readTask, timeoutTask = Task.Delay(timeoutHalf), cancellationFailed) == timeoutTask)
{
switch (++timeoutCount)
{
case 1:
await this.SendMessageCoreAsync(
new S101Message(this.keepAliveRequestSlot, new KeepAliveRequest()), null);
break;
case 2:
await this.EnqueueLogOperation(() => this.logger.LogEvent("TimeoutExpired"));
this.Dispose();
break;
}
}
if (cancellationFailed.IsCompleted)
{
await this.EnqueueLogOperation(() => this.logger.LogEvent("CancellationFailed"));
// For IO objects that do not support cancellation with CancellationToken, the recommended practice is
// to simply dispose and then wait for the async operations to complete.
connection?.Dispose();
}
try
{
return(await readTask);
}
catch (Exception ex)
{
if (((ex is OperationCanceledException) || (ex is ObjectDisposedException)) && (timeoutCount > 1))
{
throw new S101Exception(
"The remote host has failed to answer a KeepAliveRequest within half the timeout period.", ex);
}
else
{
throw;
}
}
}
public void OutOfFrameByteTest()
{
AsyncPump.Run(
async() =>
{
var first = this.GetRandomByteExcept(0xFE);
var second = this.GetRandomByteExcept(0xFE);
var prefix = new[] { this.GetRandomByteExcept() };
var third = this.GetRandomByteExcept(0xFE);
var postfix = new[] { this.GetRandomByteExcept() };
using (var asyncStream = new MemoryStream())
{
var writer = new S101Writer(asyncStream.WriteAsync);
try
{
await writer.WriteOutOfFrameByteAsync(first, CancellationToken.None);
await writer.WriteMessageAsync(KeepAliveRequestMessage, CancellationToken.None);
await writer.WriteOutOfFrameByteAsync(second, CancellationToken.None);
using (var encodingStream = await writer.WriteMessageAsync(EmberDataMessage, CancellationToken.None))
{
await encodingStream.WriteAsync(prefix, 0, prefix.Length, CancellationToken.None);
await writer.WriteOutOfFrameByteAsync(third, CancellationToken.None);
await encodingStream.WriteAsync(postfix, 0, postfix.Length, CancellationToken.None);
await encodingStream.DisposeAsync(CancellationToken.None);
}
}
finally
{
await writer.DisposeAsync(CancellationToken.None);
}
asyncStream.Position = 0;
var reader = new S101Reader(asyncStream.ReadAsync);
var firstTask = WaitForOutOfFrameByte(reader);
Assert.IsTrue(await reader.ReadAsync(CancellationToken.None));
Assert.AreEqual(0x00, reader.Message.Slot);
Assert.IsInstanceOfType(reader.Message.Command, typeof(KeepAliveRequest));
Assert.AreEqual(first, await firstTask);
var secondTask = WaitForOutOfFrameByte(reader);
Assert.IsTrue(await reader.ReadAsync(CancellationToken.None));
Assert.AreEqual(0x00, reader.Message.Slot);
Assert.IsInstanceOfType(reader.Message.Command, typeof(EmberData));
Assert.AreEqual(second, await secondTask);
var thirdTask = WaitForOutOfFrameByte(reader);
using (var payloadStream = new MemoryStream())
{
await reader.Payload.CopyToAsync(payloadStream);
var payload = payloadStream.ToArray();
Assert.AreEqual(2, payload.Length);
Assert.AreEqual(prefix.Single(), payload[0]);
Assert.AreEqual(postfix.Single(), payload[1]);
}
Assert.AreEqual(third, await thirdTask);
}
});
}
public void ExceptionTest()
{
TestStandardExceptionConstructors <S101Exception>();
AsyncPump.Run(
async() =>
{
new S101Reader((b, o, c, t) => Task.FromResult(0)).Ignore();
AssertThrow <ArgumentNullException>(() => new S101Reader(null, 1).Ignore());
AssertThrow <ArgumentOutOfRangeException>(() => new S101Reader((b, o, c, t) => Task.FromResult(0), 0).Ignore());
using (var input = new MemoryStream(
new byte[] { 0xFE, 0x00, 0x0E, 0x01, 0x01, 0x94, 0xE4, 0xFF, 0xFE, 0x00, 0x0E, 0x02, 0x01, 0xFD, 0xDC, 0xCE, 0xFF }))
{
var reader = new S101Reader(input.ReadAsync, 1);
AssertThrow <InvalidOperationException>(() => reader.Message.Ignore());
AssertThrow <InvalidOperationException>(() => reader.Payload.Ignore());
Assert.IsTrue(await reader.ReadAsync(CancellationToken.None));
Assert.IsInstanceOfType(reader.Message.Command, typeof(KeepAliveRequest));
Assert.AreEqual(0, await reader.Payload.ReadAsync(new byte[1], 0, 1, CancellationToken.None));
AssertThrow <NotSupportedException>(
() => reader.Payload.Read(new byte[1], 0, 1),
() => reader.Payload.Write(new byte[1], 0, 1));
Assert.IsTrue(await reader.ReadAsync(CancellationToken.None));
Assert.IsInstanceOfType(reader.Message.Command, typeof(KeepAliveResponse));
Assert.AreEqual(0, await reader.Payload.ReadAsync(new byte[1], 0, 1, CancellationToken.None));
Assert.IsFalse(await reader.ReadAsync(CancellationToken.None));
AssertThrow <InvalidOperationException>(() => reader.Message.Ignore());
AssertThrow <InvalidOperationException>(() => reader.Payload.Ignore());
await reader.DisposeAsync(CancellationToken.None);
await AssertThrowAsync <ObjectDisposedException>(() => reader.ReadAsync(CancellationToken.None));
AssertThrow <ObjectDisposedException>(
() => reader.Message.Ignore(), () => reader.Payload.Ignore());
}
await AssertEmpty(0xFE, 0xFF);
await AssertEmpty(0xFE, 0xFE);
for (byte invalid = 0xF8; invalid < 0xFD; ++invalid)
{
await AssertEmpty(0xFE, invalid);
}
for (ushort invalid = 0xF8; invalid < 0x100; ++invalid)
{
await AssertEmpty(0xFE, 0xFD, (byte)invalid);
}
await AssertS101Exception("Unexpected end of stream.", 0xFE, 0x00, 0x00, 0x00);
await AssertS101Exception("Unexpected end of stream.", 0xFE, 0x00, 0x0E, 0x00, 0x00, 0x00);
await AssertS101Exception(
"Unexpected end of stream.",
0xFE, 0x00, 0x0E, 0x00, 0x01, 0x80, 0x01, 0x02, 0x0A, 0x02, 0xF5, 0x78, 0xFF);
await AssertS101Exception(
"Inconsistent Slot in multi-packet message.",
0xFE, 0x00, 0x0E, 0x00, 0x01, 0x80, 0x01, 0x02, 0x0A, 0x02, 0xF5, 0x78, 0xFF,
0xFE, 0x01, 0x0E, 0x00, 0x01, 0x60, 0x01, 0x02, 0x0A, 0x02, 0x00, 0x00, 0x00);
await AssertS101Exception(
"Unexpected Message Type.",
0xFE, 0x00, 0x0F, 0x00, 0x01, 0x80, 0x01, 0x02, 0x0A, 0x02, 0x00, 0x00, 0x00);
await AssertS101Exception(
"Unexpected Command.", 0xFE, 0x00, 0x0E, 0x04, 0x01, 0x80, 0x01, 0x02, 0x0A, 0x02, 0x00, 0x00, 0x00);
await AssertS101Exception(
"Inconsistent Command in multi-packet message.",
0xFE, 0x00, 0x0E, 0x00, 0x01, 0x80, 0x01, 0x02, 0x0A, 0x02, 0xF5, 0x78, 0xFF,
0xFE, 0x00, 0x0E, 0x01, 0x01, 0x60, 0x01, 0x02, 0x0A, 0x02, 0x00, 0x00, 0x00);
await AssertS101Exception(
"Unexpected Version.", 0xFE, 0x00, 0x0E, 0x00, 0x00, 0x80, 0x01, 0x02, 0x0A, 0x02, 0x00, 0x00, 0x00);
await AssertS101Exception(
"Missing FirstPacket flag in first packet.",
0xFE, 0x00, 0x0E, 0x00, 0x01, 0x20, 0x01, 0x02, 0x0A, 0x02, 0x00, 0x00, 0x00);
await AssertS101Exception(
"FirstPacket flag in subsequent packet.",
0xFE, 0x00, 0x0E, 0x00, 0x01, 0x80, 0x01, 0x02, 0x0A, 0x02, 0xF5, 0x78, 0xFF,
0xFE, 0x00, 0x0E, 0x00, 0x01, 0xE0, 0x01, 0x02, 0x0A, 0x02, 0x00, 0x00, 0x00);
});
}
public void OutOfFrameByteTest()
{
AsyncPump.Run(
async () =>
{
var first = this.GetRandomByteExcept(0xFE);
var second = this.GetRandomByteExcept(0xFE);
var prefix = new[] { this.GetRandomByteExcept() };
var third = this.GetRandomByteExcept(0xFE);
var postfix = new[] { this.GetRandomByteExcept() };
using (var asyncStream = new MemoryStream())
{
var writer = new S101Writer(asyncStream.WriteAsync);
try
{
await writer.WriteOutOfFrameByteAsync(first, CancellationToken.None);
await writer.WriteMessageAsync(KeepAliveRequestMessage, CancellationToken.None);
await writer.WriteOutOfFrameByteAsync(second, CancellationToken.None);
using (var encodingStream = await writer.WriteMessageAsync(EmberDataMessage, CancellationToken.None))
{
await encodingStream.WriteAsync(prefix, 0, prefix.Length, CancellationToken.None);
await writer.WriteOutOfFrameByteAsync(third, CancellationToken.None);
await encodingStream.WriteAsync(postfix, 0, postfix.Length, CancellationToken.None);
await encodingStream.DisposeAsync(CancellationToken.None);
}
}
finally
{
await writer.DisposeAsync(CancellationToken.None);
}
asyncStream.Position = 0;
var reader = new S101Reader(asyncStream.ReadAsync);
var firstTask = WaitForOutOfFrameByte(reader);
Assert.IsTrue(await reader.ReadAsync(CancellationToken.None));
Assert.AreEqual(0x00, reader.Message.Slot);
Assert.IsInstanceOfType(reader.Message.Command, typeof(KeepAliveRequest));
Assert.AreEqual(first, await firstTask);
var secondTask = WaitForOutOfFrameByte(reader);
Assert.IsTrue(await reader.ReadAsync(CancellationToken.None));
Assert.AreEqual(0x00, reader.Message.Slot);
Assert.IsInstanceOfType(reader.Message.Command, typeof(EmberData));
Assert.AreEqual(second, await secondTask);
var thirdTask = WaitForOutOfFrameByte(reader);
using (var payloadStream = new MemoryStream())
{
await reader.Payload.CopyToAsync(payloadStream);
var payload = payloadStream.ToArray();
Assert.AreEqual(2, payload.Length);
Assert.AreEqual(prefix.Single(), payload[0]);
Assert.AreEqual(postfix.Single(), payload[1]);
}
Assert.AreEqual(third, await thirdTask);
}
});
}
public void PayloadTest()
{
AsyncPump.Run(
async () =>
{
#pragma warning disable SA1123 // Do not place regions within elements. Necessary so that tested code snippets can be included in the documentation.
#region Payload Test
var writtenMessage = new S101Message(0x00, new EmberData(0x01, 0x0A, 0x02));
var writtenPayload = new byte[8192];
this.Random.NextBytes(writtenPayload);
using (var encodedStream = new MemoryStream())
{
// First we create a writer, which can be used to write multiple messages.
// We specify which methods are used to write encoded output and flush it plus the size the internal
// buffer should have.
var writer = new S101Writer(encodedStream.WriteAsync);
// Next we write the message. In return we get a Stream object for the payload.
using (var payloadStream =
await writer.WriteMessageAsync(writtenMessage, CancellationToken.None))
{
// Now we write the payload.
await payloadStream.WriteAsync(writtenPayload, 0, writtenPayload.Length);
await payloadStream.DisposeAsync(CancellationToken.None);
}
await writer.DisposeAsync(CancellationToken.None);
// Reset the encoded stream to the beginning, so that we can read from it.
encodedStream.Position = 0;
// First we create a reader, which can be used to read multiple messages.
// We specify which methods are used to read encoded input.
var reader = new S101Reader(encodedStream.ReadAsync);
Assert.IsTrue(await reader.ReadAsync(CancellationToken.None)); // Read the first message
var readMessage = reader.Message;
// Assert the written and read messages are equal
Assert.AreEqual(writtenMessage.Slot, readMessage.Slot);
Assert.AreEqual(writtenMessage.Command, readMessage.Command);
using (var readPayload = new MemoryStream())
{
await reader.Payload.CopyToAsync(readPayload); // Copy the payload.
// Assert that there is only one message
Assert.IsFalse(await reader.ReadAsync(CancellationToken.None));
CollectionAssert.AreEqual(writtenPayload, readPayload.ToArray());
}
await reader.DisposeAsync(CancellationToken.None);
}
#endregion
#pragma warning restore SA1123 // Do not place regions within elements
});
}
private static async Task TestS101ReaderAsync(byte[] message, int messageCount)
{
byte[] buffer = new byte[BlockSize];
using (var stream = new MemoryStream(message))
{
var reader = new S101Reader(stream.ReadAsync, 1024);
for (int index = 0; index < messageCount; ++index)
{
await reader.ReadAsync(CancellationToken.None);
using (var payload = reader.Payload)
{
await payload.ReadAsync(buffer, 0, buffer.Length);
await payload.DisposeAsync(CancellationToken.None);
}
stream.Position = 0;
}
await reader.DisposeAsync(CancellationToken.None);
}
}
