コード例 #1
0
        public async Task Cancel_ShouldCancel_PendingAndRunningTasks()
        {
            // Arrange
            using (var breakpoint = new Breakpoint())
            {
                var queue = new CoalescingTaskQueue <int, int>((newArg, arg, running) =>
                                                               CoalesceDecision.None);

                async Task <int> TestAction(int result, CancellationToken ct)
                {
                    // ReSharper disable once AccessToDisposedClosure
                    await breakpoint.Hit().WaitForContinue();

                    ct.ThrowIfCancellationRequested();
                    return(result);
                }

                // Act
                var task1 = queue.Enqueue(ct => TestAction(6517, ct), 6517);
                var hit1  = await breakpoint.WaitForHit().TimeoutAfter(TestTimeout);

                var task2 = queue.Enqueue(ct => TestAction(101, ct), 101);

                queue.Cancel();

                hit1.Continue();
                await Task.WhenAny(task1);

                // Assert
                task1.IsCanceled.Should().BeTrue();
                task2.IsCanceled.Should().BeTrue();
            }
        }
コード例 #2
0
        public async Task Enqueue_ShouldNotJoin_CancelledRunningTask()
        {
            // Arrange
            const int expected = 6874;

            using (var breakpoint = new Breakpoint())
            {
                var queue = new CoalescingTaskQueue <int, int>((newArg, arg, running) =>
                                                               CoalesceDecision.Join);

                async Task <int> TestAction(int result, CancellationToken ct)
                {
                    // ReSharper disable once AccessToDisposedClosure
                    await breakpoint.Hit().WaitForContinue();

                    ct.ThrowIfCancellationRequested();
                    return(result);
                }

                // Act
                _ = queue.Enqueue(ct => TestAction(1981, ct), 1981);
                var hit1 = await breakpoint.WaitForHit().TimeoutAfter(TestTimeout);

                queue.Cancel();
                var task2 = queue.Enqueue(ct => TestAction(expected, ct), expected);
                hit1.Continue();
                await breakpoint.WaitForHitAndContinue().TimeoutAfter(TestTimeout);

                // Assert
                task2.Result.Should().Be(expected);
            }
        }
コード例 #3
0
        public void Cancel_ShouldSucceed_WhenNoTasksRunning()
        {
            // Arrange
            var queue = new CoalescingTaskQueue <int, int>((newArg, arg, running) =>
                                                           CoalesceDecision.None);

            // Act
            Action action = () => queue.Cancel();

            // Assert
            action.Should().NotThrow();
        }