Lawo.EmberPlusSharp.S101.S101Writer.WriteMessageAsync C# (CSharp) Method

        public Task<NonSeekableStream> WriteMessageAsync(S101Message message, CancellationToken cancellationToken)
        {
            return this.taskSingleton.Execute(() => this.WriteMessageCoreAsync(message, cancellationToken));
        }

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