C# (CSharp) Lawo.EmberPlusSharp.S101 S101Writer.WriteOutOfFrameByteAsync Examples

WriteOutOfFrameByteAsync() public method

Writes value as an out-of-frame byte.

equals 0xFE.

public WriteOutOfFrameByteAsync ( byte value, CancellationToken cancellationToken ) : Task
value	byte	The byte to write.
cancellationToken	System.Threading.CancellationToken	The token to monitor for cancellation requests.
return	Task

Example #1

        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);
                }
            });
        }

Example #2

File: S101WriterTest.cs Project: Lawo/ember-plus-sharp

        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);
                    }
                });
        }