|
private WriteMessageAsync ( |
||
| message | ||
| cancellationToken | ||
| return | Task |
|
public void ExceptionTest()
{
AsyncPump.Run(
async() =>
{
new S101Writer((b, o, c, t) => Task.FromResult(false)).Ignore();
AssertThrow <ArgumentNullException>(() => new S101Writer(null, 1).Ignore());
AssertThrow <ArgumentOutOfRangeException>(
() => new S101Writer((b, o, c, t) => Task.FromResult(false), 0).Ignore());
var writer = new S101Writer((b, o, c, t) => Task.FromResult(false), 1);
await AssertThrowAsync <ArgumentNullException>(
() => writer.WriteMessageAsync(null, CancellationToken.None));
using (var stream = await writer.WriteMessageAsync(EmberDataMessage, CancellationToken.None))
{
await AssertThrowAsync <ArgumentNullException>(
() => stream.WriteAsync(null, 0, 0, CancellationToken.None));
await AssertThrowAsync <ArgumentOutOfRangeException>(
() => stream.WriteAsync(new byte[1], -1, 1, CancellationToken.None),
() => stream.WriteAsync(new byte[1], 0, -1, CancellationToken.None));
await AssertThrowAsync <ArgumentException>(
() => stream.WriteAsync(new byte[1], 0, 2, CancellationToken.None),
() => stream.WriteAsync(new byte[1], 2, 0, CancellationToken.None),
() => stream.WriteAsync(new byte[1], 1, 1, CancellationToken.None));
await AssertThrowAsync <NotSupportedException>(
() => stream.ReadAsync(null, 0, 0, CancellationToken.None));
Assert.IsFalse(stream.CanSeek);
AssertThrow <NotSupportedException>(
() => stream.Length.Ignore(),
() => stream.SetLength(0),
() => stream.Position.Ignore(),
() => stream.Position = 0,
() => stream.Seek(0, SeekOrigin.Begin));
await AssertThrowAsync <InvalidOperationException>(() => writer.WriteMessageAsync(
new S101Message(0x00, new KeepAliveRequest()), CancellationToken.None));
await stream.DisposeAsync(CancellationToken.None);
await AssertThrowAsync <ObjectDisposedException>(
() => stream.WriteAsync(new byte[] { 2 }, 0, 1, CancellationToken.None));
}
await writer.DisposeAsync(CancellationToken.None);
await AssertThrowAsync <ObjectDisposedException>(() => writer.WriteMessageAsync(
new S101Message(0x00, new KeepAliveRequest()), CancellationToken.None));
});
}
public void S101ReadTest()
{
AsyncPump.Run(
async () =>
{
byte[] input;
using (var stream = new MemoryStream())
{
var writer = new S101Writer(stream.WriteAsync, 1024);
using (var payloadStream = await writer.WriteMessageAsync(EmberDataMessage, CancellationToken.None))
{
var payload = new byte[BlockSize];
this.Random.NextBytes(payload);
await payloadStream.WriteAsync(payload, 0, payload.Length);
await payloadStream.DisposeAsync(CancellationToken.None);
}
await writer.DisposeAsync(CancellationToken.None);
input = stream.ToArray();
}
Console.WriteLine(
"S101Reader asynchronous: {0}ms",
await TimeMethod(count => TestS101ReaderAsync(input, count), LoopCount));
});
}
public void S101ReadTest()
{
AsyncPump.Run(
async() =>
{
byte[] input;
using (var stream = new MemoryStream())
{
var writer = new S101Writer(stream.WriteAsync, 1024);
using (var payloadStream = await writer.WriteMessageAsync(EmberDataMessage, CancellationToken.None))
{
var payload = new byte[BlockSize];
this.Random.NextBytes(payload);
await payloadStream.WriteAsync(payload, 0, payload.Length);
await payloadStream.DisposeAsync(CancellationToken.None);
}
await writer.DisposeAsync(CancellationToken.None);
input = stream.ToArray();
}
Console.WriteLine(
"S101Reader asynchronous: {0}ms",
await TimeMethod(count => TestS101ReaderAsync(input, count), LoopCount));
});
}
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 TestS101WriterAsync(byte[] block, int blockCount)
{
var completed = Task.FromResult(false);
var writer = new S101Writer((b, o, c, t) => completed, 1024);
using (var payloadStream = await writer.WriteMessageAsync(EmberDataMessage, CancellationToken.None))
{
for (int index = 0; index < blockCount; ++index)
{
await payloadStream.WriteAsync(block, 0, block.Length);
}
await payloadStream.DisposeAsync(CancellationToken.None);
}
await writer.DisposeAsync(CancellationToken.None);
}
protected static async Task <MemoryStream> GetS101MessageStreamAsync(byte[] payload)
{
var stream = new MemoryStream();
var writer = new S101Writer(stream.WriteAsync);
using (var messageStream = await writer.WriteMessageAsync(EmberDataMessage, CancellationToken.None))
{
if (payload != null)
{
await messageStream.WriteAsync(payload, 0, payload.Length);
}
await messageStream.DisposeAsync(CancellationToken.None);
}
await writer.DisposeAsync(CancellationToken.None);
stream.Position = 0;
return(stream);
}
private static async Task <byte[]> Encode(S101Message message, byte[] payload = null)
{
using (var asyncStream = new MemoryStream())
{
var writer = new S101Writer(
async(b, o, c, t) =>
{
// This makes the read operation truly asynchronous, which helps to improve code coverage.
await Task.Delay(1);
await asyncStream.WriteAsync(b, o, c, t);
},
1);
using (var encodingStream = await writer.WriteMessageAsync(message, CancellationToken.None))
{
Assert.AreEqual(encodingStream == null, payload == null);
if (encodingStream != null)
{
Assert.IsFalse(encodingStream.CanRead);
Assert.IsTrue(encodingStream.CanWrite);
await encodingStream.WriteAsync(payload, 0, payload.Length, CancellationToken.None);
await encodingStream.FlushAsync(CancellationToken.None);
await encodingStream.DisposeAsync(CancellationToken.None);
Assert.IsFalse(encodingStream.CanWrite);
await AssertThrowAsync <ObjectDisposedException>(
() => encodingStream.WriteAsync(new byte[] { 0 }, 0, 1, CancellationToken.None));
await AssertThrowAsync <ObjectDisposedException>(
() => encodingStream.FlushAsync(CancellationToken.None));
}
}
await writer.DisposeAsync(CancellationToken.None);
return(asyncStream.ToArray());
}
}
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 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);
}
});
}
private static async Task<byte[]> Encode(S101Message message, byte[] payload = null)
{
using (var asyncStream = new MemoryStream())
{
var writer = new S101Writer(
async (b, o, c, t) =>
{
// This makes the read operation truly asynchronous, which helps to improve code coverage.
await Task.Delay(1);
await asyncStream.WriteAsync(b, o, c, t);
},
1);
using (var encodingStream = await writer.WriteMessageAsync(message, CancellationToken.None))
{
Assert.AreEqual(encodingStream == null, payload == null);
if (encodingStream != null)
{
Assert.IsFalse(encodingStream.CanRead);
Assert.IsTrue(encodingStream.CanWrite);
await encodingStream.WriteAsync(payload, 0, payload.Length, CancellationToken.None);
await encodingStream.FlushAsync(CancellationToken.None);
await encodingStream.DisposeAsync(CancellationToken.None);
Assert.IsFalse(encodingStream.CanWrite);
await AssertThrowAsync<ObjectDisposedException>(
() => encodingStream.WriteAsync(new byte[] { 0 }, 0, 1, CancellationToken.None));
await AssertThrowAsync<ObjectDisposedException>(
() => encodingStream.FlushAsync(CancellationToken.None));
}
}
await writer.DisposeAsync(CancellationToken.None);
return asyncStream.ToArray();
}
}
public void ExceptionTest()
{
AsyncPump.Run(
async () =>
{
new S101Writer((b, o, c, t) => Task.FromResult(false)).Ignore();
AssertThrow<ArgumentNullException>(() => new S101Writer(null, 1).Ignore());
AssertThrow<ArgumentOutOfRangeException>(
() => new S101Writer((b, o, c, t) => Task.FromResult(false), 0).Ignore());
var writer = new S101Writer((b, o, c, t) => Task.FromResult(false), 1);
await AssertThrowAsync<ArgumentNullException>(
() => writer.WriteMessageAsync(null, CancellationToken.None));
using (var stream = await writer.WriteMessageAsync(EmberDataMessage, CancellationToken.None))
{
await AssertThrowAsync<ArgumentNullException>(
() => stream.WriteAsync(null, 0, 0, CancellationToken.None));
await AssertThrowAsync<ArgumentOutOfRangeException>(
() => stream.WriteAsync(new byte[1], -1, 1, CancellationToken.None),
() => stream.WriteAsync(new byte[1], 0, -1, CancellationToken.None));
await AssertThrowAsync<ArgumentException>(
() => stream.WriteAsync(new byte[1], 0, 2, CancellationToken.None),
() => stream.WriteAsync(new byte[1], 2, 0, CancellationToken.None),
() => stream.WriteAsync(new byte[1], 1, 1, CancellationToken.None));
await AssertThrowAsync<NotSupportedException>(
() => stream.ReadAsync(null, 0, 0, CancellationToken.None));
Assert.IsFalse(stream.CanSeek);
AssertThrow<NotSupportedException>(
() => stream.Length.Ignore(),
() => stream.SetLength(0),
() => stream.Position.Ignore(),
() => stream.Position = 0,
() => stream.Seek(0, SeekOrigin.Begin));
await AssertThrowAsync<InvalidOperationException>(() => writer.WriteMessageAsync(
new S101Message(0x00, new KeepAliveRequest()), CancellationToken.None));
await stream.DisposeAsync(CancellationToken.None);
await AssertThrowAsync<ObjectDisposedException>(
() => stream.WriteAsync(new byte[] { 2 }, 0, 1, CancellationToken.None));
}
await writer.DisposeAsync(CancellationToken.None);
await AssertThrowAsync<ObjectDisposedException>(() => writer.WriteMessageAsync(
new S101Message(0x00, new KeepAliveRequest()), CancellationToken.None));
});
}
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 TestS101WriterAsync(byte[] block, int blockCount)
{
var completed = Task.FromResult(false);
var writer = new S101Writer((b, o, c, t) => completed, 1024);
using (var payloadStream = await writer.WriteMessageAsync(EmberDataMessage, CancellationToken.None))
{
for (int index = 0; index < blockCount; ++index)
{
await payloadStream.WriteAsync(block, 0, block.Length);
}
await payloadStream.DisposeAsync(CancellationToken.None);
}
await writer.DisposeAsync(CancellationToken.None);
}