Async version of the ManualResetEvent
        public async Task WaitAsync_CancellationToken_Cancel() {
            var amre = new AsyncManualResetEvent();
            var cts = new CancellationTokenSource();

            var task = amre.WaitAsync(cts.Token);
            task.Should().NotBeCompleted();

            cts.Cancel();
            await Task.Delay(10);

            task.Should().BeCanceled();
        }
Esempio n. 2
0
            public async Task CancelAll_CancellableHangingLoop() {
                var testMrs = new AsyncManualResetEvent();
                var plotMrs = new AsyncManualResetEvent();
                _callback.PlotHandler = (message, ct) => {
                    testMrs.Set();
                    return plotMrs.WaitAsync(ct);
                };

                Task responceTask;
                using (var interaction = await _session.BeginInteractionAsync()) {
                    responceTask = interaction.RespondAsync("plot(1)\n");
                }

                await testMrs.WaitAsync().Should().BeCompletedAsync();

                await _session.CancelAllAsync().Should().BeCompletedAsync();

                _session.IsHostRunning.Should().BeTrue();
                responceTask.Should().BeCanceled();
            }
Esempio n. 3
0
        public async Task StopReentrantLoop() {
            var callback = new RSessionCallbackStub();
            var session = new RSession(0, _brokerClient, new AsyncReaderWriterLock().CreateExclusiveReaderLock(), () => { });

            await session.StartHostAsync(new RHostStartupInfo {
                Name = _testMethod.Name
            }, callback, 50000);

            var testMrs = new AsyncManualResetEvent();
            callback.PlotHandler = (message, ct) => {
                testMrs.Set();
                return session.EvaluateAsync("x <- 1\n");
            };

            Task responceTask;
            using (var interaction = await session.BeginInteractionAsync()) {
                responceTask = interaction.RespondAsync("plot(1)\n");
            }

            await testMrs.WaitAsync().Should().BeCompletedAsync();

            await session.StopHostAsync().Should().BeCompletedAsync(20000);
            session.IsHostRunning.Should().BeFalse();

            await responceTask.Should().BeCanceledAsync();
        }
 public async Task WaitAsync_CancellationToken_Canceled() {
     var amre = new AsyncManualResetEvent();
     Func<Task> f = () => amre.WaitAsync(new CancellationToken(true));
     await f.ShouldThrowAsync<OperationCanceledException>();
 }
Esempio n. 5
0
            public async Task CancelAll_HangingLoop_Cancel() {
                var testMrs = new AsyncManualResetEvent();
                var plotMrs = new AsyncManualResetEvent();
                _callback.PlotHandler = (message, ct) => {
                    testMrs.Set();
                    // ct is ignored on purpose
                    return plotMrs.WaitAsync();
                };

                var cancelAllCts = new CancellationTokenSource();
                Task responceTask;
                using (var interaction = await _session.BeginInteractionAsync()) {
                    responceTask = interaction.RespondAsync("plot(1)\n");
                }

                await testMrs.WaitAsync().Should().BeCompletedAsync();
                var cancelAllAsyncTask = _session.CancelAllAsync(cancelAllCts.Token);

                await cancelAllAsyncTask.Should().NotBeCompletedAsync();

                cancelAllCts.Cancel();
                await cancelAllAsyncTask.Should().BeCanceledAsync();

                _session.IsHostRunning.Should().BeTrue();
                await responceTask.Should().BeCanceledAsync();
                plotMrs.Set();
            }