public void CompletionIsCanceledAfterCancellation()
        {
            var sut = new BufferedChannel <int>(2);

            sut.Terminate();
            sut.Completion.IsCanceled.ShouldBe(true);
            sut.Completion.Exception.ShouldBeNull();
        }
        public void FailCancelsWriteTasks()
        {
            var sut   = new BufferedChannel <int>(0);
            var task1 = sut.TryWriteAsync(1);
            var task2 = sut.TryWriteAsync(1);

            sut.Terminate(new InvalidOperationException());
            Should.Throw <InvalidOperationException>(task1, Timeout1Sec);
            Should.Throw <InvalidOperationException>(task2, Timeout1Sec);
        }
        public void FailCancelsReadTasks()
        {
            var sut   = new BufferedChannel <int>(0);
            var task1 = sut.TryReadAsync();
            var task2 = sut.TryReadAsync();

            sut.Terminate(new InvalidOperationException());
            Should.Throw <InvalidOperationException>(task1.AsTask(), Timeout1Sec);
            Should.Throw <InvalidOperationException>(task2.AsTask(), Timeout1Sec);
        }
        public void CancellationCancelsWriteTasks()
        {
            var sut   = new BufferedChannel <int>(0);
            var task1 = sut.TryWriteAsync(1);
            var task2 = sut.TryWriteAsync(1);

            sut.Terminate();
            Should.Throw <OperationCanceledException>(task1, Timeout1Sec);
            Should.Throw <OperationCanceledException>(task2, Timeout1Sec);
        }
        public void CancellationCancelsReadTasks()
        {
            var sut   = new BufferedChannel <int>(0);
            var task1 = sut.TryReadAsync();
            var task2 = sut.TryReadAsync();

            sut.Terminate();
            Should.Throw <OperationCanceledException>(task1.AsTask(), Timeout1Sec);
            Should.Throw <OperationCanceledException>(task2.AsTask(), Timeout1Sec);
        }
        public void CompletionHasErrorAfterFail()
        {
            var sut       = new BufferedChannel <int>(2);
            var exception = new ArgumentOutOfRangeException();

            sut.Terminate(exception);
            sut.Completion.IsFaulted.ShouldBe(true);
            sut.Completion.Exception.ShouldNotBe(null);
            sut.Completion.Exception.InnerException.ShouldBe(exception);
        }
        public void FailCancelsWriteTasks()
        {
            var sut   = new BufferedChannel <int>(0);
            var task1 = sut.TryWriteSafeAsync(1);
            var task2 = sut.TryWriteSafeAsync(1);

            sut.Terminate(new InvalidOperationException());
            task1.Result.ShouldBeFalse();
            task2.Result.ShouldBeFalse();
        }
        public void CancellationCancelsWriteTasks()
        {
            var sut   = new BufferedChannel <int>(0);
            var task1 = sut.TryWriteSafeAsync(1);
            var task2 = sut.TryWriteSafeAsync(1);

            sut.Terminate();
            task1.Result.ShouldBeFalse();
            task2.Result.ShouldBeFalse();
        }
        public void CancellationCancelsReadTasks()
        {
            var sut   = new BufferedChannel <int>(0);
            var task1 = sut.TryReadSafeAsync();
            var task2 = sut.TryReadSafeAsync();

            sut.Terminate();
            task1.Result.HasValue.ShouldBeFalse();
            task2.Result.HasValue.ShouldBeFalse();
        }
        public void TerminationCompletesChannelWithException()
        {
            var sut = new BufferedChannel <int>(2);

            sut.TryWrite(1);
            sut.TryWrite(2);
            sut.Terminate(new InvalidOperationException());
            sut.Completion.IsCompleted.ShouldBe(false);
            sut.TryRead(out int _).ShouldBe(true);
            sut.TryRead(out int _).ShouldBe(true);
            Should.Throw <InvalidOperationException>(() => sut.TryReadAsync().AsTask(), Timeout1Sec);
            sut.Completion.IsFaulted.ShouldBeTrue();
        }
        public void CancellationCompletesChannel()
        {
            var sut = new BufferedChannel <int>(2);

            sut.TryWrite(1);
            sut.TryWrite(2);
            sut.Terminate();
            sut.Completion.IsCompleted.ShouldBe(false);
            sut.TryRead(out int _).ShouldBe(true);
            sut.TryRead(out int _).ShouldBe(true);
            Should.Throw <TaskCanceledException>(sut.TryReadAsync().AsTask(), Timeout1Sec);
            sut.Completion.IsCanceled.ShouldBeTrue();
        }
        public void FailCompletesChannelEvenIfBufferIsNotEmpty()
        {
            var sut = new BufferedChannel <int>(2);

            sut.TryWriteSafe(1);
            sut.TryWriteSafe(2);
            sut.Terminate(new InvalidOperationException());
            sut.Completion.IsCompleted.ShouldBe(false);
            sut.TryReadSafe(out int _).ShouldBe(true);
            sut.TryReadSafe(out int _).ShouldBe(true);
            var result = Should.CompleteIn(() => sut.TryReadSafeAsync().AsTask(), TimeSpan.FromSeconds(1));

            result.HasValue.ShouldBeFalse();
            sut.Completion.IsFaulted.ShouldBeTrue();
        }
        public void CancellationCompletesChannel()
        {
            var sut = new BufferedChannel <int>(2);

            sut.TryWriteSafe(1);
            sut.TryWriteSafe(2);
            sut.Terminate();
            sut.Completion.IsCompleted.ShouldBe(false);
            sut.TryReadSafe(out int _).ShouldBe(true);
            sut.TryReadSafe(out int _).ShouldBe(true);
            var result = sut.TryReadSafeAsync().ShouldCompleteIn(Timeout1Sec);

            result.HasValue.ShouldBeFalse();
            sut.Completion.IsCanceled.ShouldBeTrue();
        }