/// <summary> /// Returns the previous command. Note that returning this is safe, since the state of the /// immortal can't be changed with the return value. /// </summary> public async Task <string> HostPreviousCommandAsync() { thisProxy.DecCurrentCommandFork(); await _currentCommandHistoryIndexUpdated.DequeueAsync(); return(HostCurrentCommand()); }
public IEnumerator FirstInFirstOut() => RunAsync(async() => { var asyncQueue = new AsyncQueue <int>(); asyncQueue.Enqueue(1); asyncQueue.Enqueue(2); Assert.That(await asyncQueue.DequeueAsync(), Is.EqualTo(1)); Assert.That(await asyncQueue.DequeueAsync(), Is.EqualTo(2)); });
public async Task BothTasksShouldReturnSameValue() { var queue = new AsyncQueue <int>(); var task1 = queue.DequeueAsync(); var task2 = queue.DequeueAsync(); queue.Enqueue(1); await Task.WhenAny(task1, task2); task1.IsCompleted.ShouldNotBe(task2.IsCompleted); }
public void Items_should_be_dequeued_in_the_order_they_were_enqueued_2() { var subject = new AsyncQueue<int>(); var result = subject.DequeueAsync(CancellationToken.None); var result2 = subject.DequeueAsync(CancellationToken.None); subject.Enqueue(10); subject.Enqueue(11); result.Result.Should().Be(10); result2.Result.Should().Be(11); }
public async Task DequeueShouldReturnSecondElementWhenCalledTwice() { var queue = new AsyncQueue <int>(); queue.Enqueue(1234); queue.Enqueue(5678); await queue.DequeueAsync(); var item = await queue.DequeueAsync(); item.ShouldBe(5678); }
public void Enqueue_Item_ItemEnqueued() { // ARRANGE var item = "testItem"; // ACT _queue.Enqueue(item); // ASSERT var dequeuedItem = _queue.DequeueAsync().GetAwaiter().GetResult(); Assert.That(item, Is.EqualTo(dequeuedItem)); }
public async Task Should_complete_dequeue_task_in_order() { using var queue = new AsyncQueue <int>(); var firstTask = queue.DequeueAsync(); var secondTask = queue.DequeueAsync(); var thirdTask = queue.DequeueAsync(); queue.Enqueue(1); queue.Enqueue(2); queue.Enqueue(3); (await firstTask.ConfigureAwait(false)).Should().Be(1); (await secondTask.ConfigureAwait(false)).Should().Be(2); (await thirdTask.ConfigureAwait(false)).Should().Be(3); queue.Count.Should().Be(0); }
public void AsyncQueue_DequeueBlocksOnEmptyQueue() { // Create a queue in blocking dequeue mode. var asyncQueue = new AsyncQueue <int>(); Assert.False(asyncQueue.DequeueAsync().Wait(100)); }
static void Main(string[] args) { var random = new Random(); var asyncQueue = new AsyncQueue <FooTask>(); for (int i = 0; i < 100; i++) { Task.Run(async() => { while (true) { asyncQueue.Enqueue(new FooTask()); await Task.Delay(random.Next(1000)); } }); } for (int i = 0; i < 10; i++) { Task.Run(async() => { while (true) { var fooTask = await asyncQueue.DequeueAsync(); fooTask.Do(); Console.WriteLine($"剩余 {asyncQueue.Count}"); await Task.Delay(random.Next(50)); } }); } Console.Read(); }
public async Task DequeueManyThenComplete() { var queue = new AsyncQueue <int>(); var list = new List <Task <int> >(); for (var i = 0; i < 4; i++) { list.Add(queue.DequeueAsync()); } queue.Complete(); foreach (var task in list) { var threw = false; try { await task.ConfigureAwait(false); } catch (OperationCanceledException) { threw = true; } Assert.True(threw); } }
internal static void VerifyEvents(AsyncQueue <CompilationEvent> queue, params string[] expectedEvents) { var expected = new HashSet <string>(); foreach (var s in expectedEvents) { if (!expected.Add(s)) { Console.WriteLine("Expected duplicate " + s); } } var actual = ArrayBuilder <CompilationEvent> .GetInstance(); while (queue.Count > 0 || !queue.IsCompleted) { var te = queue.DequeueAsync(CancellationToken.None); Assert.True(te.IsCompleted); actual.Add(te.Result); } bool unexpected = false; foreach (var a in actual) { var eventString = a.ToString(); if (!expected.Remove(eventString)) { if (!unexpected) { Console.WriteLine("UNEXPECTED EVENTS:"); unexpected = true; } Console.WriteLine(eventString); } } if (expected.Count != 0) { Console.WriteLine("MISSING EVENTS:"); } foreach (var e in expected) { Console.WriteLine(e); } if (unexpected || expected.Count != 0 || expectedEvents.Length != actual.Count) { bool first = true; Console.WriteLine("ACTUAL EVENTS:"); foreach (var e in actual) { if (!first) { Console.WriteLine(","); } first = false; Console.Write("\"" + e.ToString() + "\""); } Console.WriteLine(); Assert.True(false); } }
public void DequeueAsync_before_Enqueue() { var queue = new AsyncQueue<string>(); var task = queue.DequeueAsync().AssertNotCompleted(); queue.Enqueue("A"); task.AssertResult("A"); }
public async Task <IClientConnection> GetNextClientConnectionAsync() { if (!IsListening) { throw new InvalidOperationException(); } Debug.Assert(_cancellationTokenSource is object); Debug.Assert(_queue is object); var listenResult = await _queue.DequeueAsync(_cancellationTokenSource.Token).ConfigureAwait(false); if (listenResult.Exception is object) { throw new Exception("Error occurred listening for connections", listenResult.Exception); } if (listenResult.NamedPipeClientConnection is null) { // The AsyncQueue<> implementation will resolve all out-standing waiters as default // when Complete is called. Treat that as cancellation from the perspective of our // callers throw new OperationCanceledException(); } return(listenResult.NamedPipeClientConnection); }
static internal async Task WaitForJobsToFinishAndThenWaitAsync() { int jobsEnded = 0; while (jobsEnded < _numJobs) { await finishedTokenQ.DequeueAsync(); jobsEnded++; } Console.WriteLine("DONE"); FlushOutput(); await finishedTokenQ.DequeueAsync(); return; }
public void Dequeue_should_return_an_uncompleted_task_when_no_items_exist() { var subject = new AsyncQueue<int>(); var result = subject.DequeueAsync(CancellationToken.None); result.IsCompleted.Should().BeFalse(); }
public async Task AsyncQueueEnqueueAndDequeueTestWithMultiThread() { var asyncQueue = new AsyncQueue <Foo>(); var foo = new Foo(); var task = Task.Run(async() => { int n = 0; while (true) { n++; if (n == MaxCount) { break; } var temp = await asyncQueue.DequeueAsync(); if (temp is null) { return; } } }); for (int i = 0; i < MaxCount; i++) { asyncQueue.Enqueue(foo); } await task; }
public override async Task ListenUserState(Empty request, IServerStreamWriter <UserState> responseStream, ServerCallContext context) { var key = Guid.NewGuid().ToString(); try { var queue = new AsyncQueue <UserState>(); if (!mUserStateRequests.TryAdd(key, queue)) { throw new Exception("Cannot register user state listener!"); } foreach (var startRequestsKey in mStartRequests.Keys) { await responseStream.WriteAsync(new UserState { ID = startRequestsKey, Connected = true }); } await responseStream.WriteAsync(new UserState { ID = mHostID, Connected = true }); while (true) { var state = await queue.DequeueAsync(context.CancellationToken); context.CancellationToken.ThrowIfCancellationRequested(); await responseStream.WriteAsync(state); } } catch (Exception e) { Debug.LogError(e); mUserStateRequests.TryRemove(key, out var q); throw; } }
public async Task ListenCreation(IServerStreamWriter <TState> responseStream, ServerCallContext context) { try { foreach (var key in mRegistred.Keys) { var reg = await mRegistred.GetValueAsync(key, context.CancellationToken); await responseStream.WriteAsync(mCreateState(reg.Info)); } while (true) { var registration = await mRegistrations.DequeueAsync(context.CancellationToken); context.CancellationToken.ThrowIfCancellationRequested(); mRegistred.AddOrUpdate(registration.Info.ID, registration); await responseStream.WriteAsync(mCreateState(registration.Info)); } } catch (Exception e) { Debug.LogError(e); throw; } }
/// <summary> /// 开始异步写入日志文件。 /// </summary> /// <param name="file">日志文件。</param> /// <param name="logQueue">要接收日志的异步队列。</param> /// <param name="append">是追加文件还是覆盖文件。</param> private async void StartWriteLogFile(FileInfo file, AsyncQueue <string> logQueue, bool append) { var directory = file.Directory; if (directory != null && !Directory.Exists(directory.FullName)) { directory.Create(); } var writerLazy = CreateWriterLazy(file, append); while (true) { var text = await logQueue.DequeueAsync().ConfigureAwait(false); var writer = await writerLazy.Value.ConfigureAwait(false); if (writer == null) { writerLazy = CreateWriterLazy(file, append); } else { await writer.WriteLineAsync(text).ConfigureAwait(false); } } }
public void DequeueCancellationAndCompletionStress() { var queue = new AsyncQueue <GenericParameterHelper>(); queue.Complete(); // This scenario was proven to cause a deadlock before a bug was fixed. // This scenario should remain to protect against regressions. int iterations = 0; var stopwatch = Stopwatch.StartNew(); while (stopwatch.ElapsedMilliseconds < TestTimeout / 2) { var cts = new CancellationTokenSource(); using (var barrier = new Barrier(2)) { var otherThread = Task.Run(delegate { Assert.True(barrier.SignalAndWait(TestTimeout)); queue.DequeueAsync(cts.Token); Assert.True(barrier.SignalAndWait(TestTimeout)); }); Assert.True(barrier.SignalAndWait(TestTimeout)); cts.Cancel(); Assert.True(barrier.SignalAndWait(TestTimeout)); Assert.True(otherThread.Wait(TestTimeout)); } iterations++; } this.Logger.WriteLine("Iterations: {0}", iterations); }
public void Can_dismiss_persistent_action_and_get_notified_about_it() { using (var database = CreateDocumentDatabase()) { database.NotificationCenter.Options.DatabaseStatsThrottle = TimeSpan.MaxValue; var alert = GetSampleAlert(); database.NotificationCenter.Add(alert); var actions = new AsyncQueue <DynamicJsonValue>(); var writer = new TestWebSocketWriter(); using (database.NotificationCenter.TrackActions(actions, writer)) { database.NotificationCenter.Dismiss(alert.Id); IEnumerable <NotificationTableValue> alerts; using (database.NotificationCenter.GetStored(out alerts)) { var jsonAlerts = alerts.ToList(); Assert.Equal(0, jsonAlerts.Count); } } Assert.Equal(1, actions.Count); var notification = actions.DequeueAsync().Result; Assert.NotNull(notification); Assert.Equal(alert.Id, notification[nameof(NotificationUpdated.NotificationId)]); Assert.Equal(NotificationUpdateType.Dismissed, notification[nameof(NotificationUpdated.UpdateType)]); } }
private async Task GotoNextStepAsync(string stepDescription) { NextStepRun.Text = stepDescription; await _queue.DequeueAsync(); LastStepRun.Text = NextStepRun.Text; }
public async Task SingleTask_EnqueueMultipleItems_DequeuedInOriginalOrder() { var queue = new AsyncQueue <int>(); queue.Enqueue(42); queue.Enqueue(43); queue.Enqueue(44); Assert.AreEqual(3, queue.Count); Assert.AreEqual(42, await queue.DequeueAsync()); Assert.AreEqual(43, await queue.DequeueAsync()); Assert.AreEqual(44, await queue.DequeueAsync()); Assert.AreEqual(0, queue.Count); }
public AwaitableWrapper <Msg> RecvMsgR(BytesView buf) { if (readEOF) { ThrowInvalidOperation(); } raR.Reset(); raR_deq = recvQueue.DequeueAsync(out raR_noWaiting); if (raR_continuation == null) { raR_continuation = () => { Msg m; var tmp = raR_deq; raR_deq = null; if (!tmp.TryGetResult(out m, out var ex)) { raR.SetException(ex); } else { try { m = rar_continuation2(m); } catch (Exception e) { raR.SetException(e); return; } raR.SetResult(m); } };
static void Main(string[] args) { finishedTokenQ = new AsyncQueue <int>(); int coordinatorPort = 1500; string clientInstanceName = "client"; string serverInstanceName = "server"; if (args.Length >= 1) { clientInstanceName = args[0]; } if (args.Length == 2) { serverInstanceName = args[1]; } using (var coordinatorOutput = new StreamWriter("CoordOut.txt", false)) { var iCListener = new TextWriterTraceListener(coordinatorOutput); Trace.Listeners.Add(iCListener); GenericLogsInterface.SetToGenericLogs(); using (AmbrosiaFactory.Deploy <IClient3>(clientInstanceName, new Client3(serverInstanceName, clientInstanceName), coordinatorPort)) { finishedTokenQ.DequeueAsync().Wait(); } } }
/// <summary> /// Worker of <see cref="AsyncQueue_DequeueParallelAsync"/> test that tries to consume items from the queue /// until the last item is reached or cancellation is triggered. /// </summary> /// <param name="asyncQueue">Queue to consume items from.</param> /// <param name="list">List to add consumed items to.</param> /// <param name="lastItem">Value of the last item that will be added to the queue.</param> /// <param name="cts">Cancellation source to cancel when we are done.</param> private async Task AsyncQueue_DequeueParallelAsync_WorkerAsync(AsyncQueue <int> asyncQueue, List <int> list, int lastItem, CancellationTokenSource cts) { while (true) { try { int item = await asyncQueue.DequeueAsync(cts.Token); await Task.Delay(this.random.Next(10)); list.Add(item); // If we reached the last item, signal cancel to the other worker and finish. if (item == lastItem) { cts.Cancel(); break; } } catch (OperationCanceledException) { break; } } }
private void SecondSession() { s2 = fht.NewSession(f, null, threadAffinitized); ev.Set(); while (true) { var cmd = q.DequeueAsync().Result; switch (cmd) { case "refresh": s2.Refresh(); ev.Set(); break; case "dispose": s2.Dispose(); ev.Set(); return; default: throw new Exception("Unsupported command"); } } }
public async Task ParallelSendAndDequeueAsync(int count) { var cancellation = new CancellationTokenSource(TimeSpan.FromSeconds(5)); var options = new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount, TaskScheduler = TaskScheduler.Default }; var asyncQueue = new AsyncQueue <int>(); var items = Enumerable.Range(0, count).ToArray(); var expectedSum = items.Sum(); var actualSum = 0; var ct = 0; var receiveTask = new Func <Task>(async() => { await Task.Yield(); while (cancellation.IsCancellationRequested == false) { var value = await asyncQueue.DequeueAsync(cancellation.Token).ConfigureAwait(false); Interlocked.Add(ref actualSum, value); if (Interlocked.Increment(ref ct) == count) { return; } } })(); Parallel.For(0, count, options, i => Assert.True(asyncQueue.TryEnqueue(i), "fail to send")); await receiveTask.ConfigureAwait(false); Assert.Equal(expectedSum, actualSum); Assert.Equal(0, asyncQueue.Count); }
static void Main(string[] args) { finishedTokenQ = new AsyncQueue <int>(); int receivePort = 1001; int sendPort = 1000; string clientInstanceName = "client"; string serverInstanceName = "server"; if (args.Length >= 1) { clientInstanceName = args[0]; } if (args.Length == 2) { serverInstanceName = args[1]; } Client2 client = new Client2(serverInstanceName); using (var c = AmbrosiaFactory.Deploy <IClient2>(clientInstanceName, client, receivePort, sendPort)) { while (finishedTokenQ.IsEmpty) { finishedTokenQ.DequeueAsync().Wait(); } } }
static void Main(string[] args) { ParseAndValidateOptions(args); finishedTokenQ = new AsyncQueue <int>(); // for debugging don't want to auto continue but for test automation want this to auto continue if (!_autoContinue) { Console.WriteLine("Pausing execution of " + _perfJob + ". Press enter to deploy and continue."); Console.ReadLine(); } #if DEBUG Console.WriteLine("*X* Connecting to: " + _perfServer + "...."); #endif var myClient = new Job(_perfServer, _numRounds); // Use "Empty" as the type parameter because this container doesn't run a service // that responds to any RPC calls. using (var c = AmbrosiaFactory.Deploy <IJob>(_perfJob, myClient, _receivePort, _sendPort)) { finishedTokenQ.DequeueAsync().Wait(); } }
public override async Task ListenChat(Empty request, IServerStreamWriter <ChatMessage> responseStream, ServerCallContext context) { var key = Guid.NewGuid(); try { var queue = new AsyncQueue <ChatMessage>(); if (!mChatListeners.TryAdd(key, queue)) { throw new Exception("Cannot register user state listener!"); } while (true) { var message = await queue.DequeueAsync(context.CancellationToken); context.CancellationToken.ThrowIfCancellationRequested(); await responseStream.WriteAsync(message); } } catch (Exception e) { Debug.LogError(e); mChatListeners.TryRemove(key, out var q); throw; } }
public void Dequeue_should_complete_when_an_item_is_added_to_the_queue() { var subject = new AsyncQueue<int>(); var result = subject.DequeueAsync(CancellationToken.None); subject.Enqueue(10); result.Result.Should().Be(10); }
public async Task DequeueThenEnqueue() { var queue = new AsyncQueue<int>(); var task = queue.DequeueAsync(); Assert.False(task.IsCompleted); queue.Enqueue(13); Assert.Equal(13, await task.ConfigureAwait(false)); }
public void Enqueue() { var queue = new AsyncQueue<int>(); queue.Enqueue(42); var task = queue.DequeueAsync(); Assert.True(task.IsCompleted); Assert.Equal(42, task.Result); }
public async Task Should_be_able_to_cancel_dequeue() { using var queue = new AsyncQueue <int>(); using var dequeueCts = new CancellationTokenSource(); var dequeueTask = queue.DequeueAsync(dequeueCts.Token); var _ = Task.Run(dequeueCts.Cancel, CancellationToken.None); await Assert.ThrowsAnyAsync <OperationCanceledException>(() => dequeueTask).ConfigureAwait(false); }
public void ShouldNotReturnCompletedTaskWhenThereIsNothingInTheQUEUE() { var queue = new AsyncQueue <char>(); var task = queue.DequeueAsync(); task.IsCompleted.ShouldBeFalse(); }
public async Task AsyncQueueSkipsCancelledTasks() { AsyncQueue<int> inputQueue = new AsyncQueue<int>(); // Queue up a couple of tasks to wait for input CancellationTokenSource cancellationSource = new CancellationTokenSource(); Task<int> taskOne = inputQueue.DequeueAsync(cancellationSource.Token); Task<int> taskTwo = inputQueue.DequeueAsync(); // Cancel the first task and then enqueue a number cancellationSource.Cancel(); await inputQueue.EnqueueAsync(1); // Did the second task get the number? Assert.Equal(TaskStatus.Canceled, taskOne.Status); Assert.Equal(TaskStatus.RanToCompletion, taskTwo.Status); Assert.Equal(1, taskTwo.Result); }
internal static void VerifyEvents(AsyncQueue<CompilationEvent> queue, params string[] expectedEvents) { var expected = new HashSet<string>(); foreach (var s in expectedEvents) { if (!expected.Add(s)) { Console.WriteLine("Expected duplicate " + s); } } var actual = ArrayBuilder<CompilationEvent>.GetInstance(); while (queue.Count > 0 || !queue.IsCompleted) { var te = queue.DequeueAsync(); Assert.True(te.IsCompleted); actual.Add(te.Result); } bool unexpected = false; foreach (var a in actual) { var eventString = a.ToString(); if (!expected.Remove(eventString)) { if (!unexpected) { Console.WriteLine("UNEXPECTED EVENTS:"); unexpected = true; } Console.WriteLine(eventString); } } if (expected.Count != 0) { Console.WriteLine("MISSING EVENTS:"); } foreach (var e in expected) { Console.WriteLine(e); } if (unexpected || expected.Count != 0) { bool first = true; Console.WriteLine("ACTUAL EVENTS:"); foreach (var e in actual) { if (!first) { Console.WriteLine(","); } first = false; Console.Write("\"" + e.ToString() + "\""); } Console.WriteLine(); Assert.True(false); } }
public void CompleteAllDequeue() { var queue = new AsyncQueue<string>(); var tasks = Enumerable.Range(0, 3).Select(_ => queue.DequeueAsync()).ToList(); queue.CompleteAllDequeue("X").Dispose(); foreach (var task in tasks) { task.AssertResult("X"); } }
public void CancelAllDequeue() { var queue = new AsyncQueue<string>(); var tasks = Enumerable.Range(0, 3).Select(_ => queue.DequeueAsync()).ToList(); queue.CancelAllDequeue().Dispose(); foreach (var task in tasks) { task.AssertCanceled(); } }
public void DequeueAsync_canceled_after_completion() { var queue = new AsyncQueue<string>(); queue.Enqueue("A"); using (var cts = new CancellationTokenSource()) { var task = queue.DequeueAsync(cts.Token); cts.Cancel(); task.AssertResult("A"); } }
private async Task ConsumeItems( AsyncQueue<int> inputQueue, ConcurrentBag<int> outputItems, CancellationToken cancellationToken) { while (!cancellationToken.IsCancellationRequested) { int consumedItem = await inputQueue.DequeueAsync(cancellationToken); outputItems.Add(consumedItem); } }
public async Task DequeueManyThenEnqueueMany() { var queue = new AsyncQueue<int>(); var count = 4; var list = new List<Task<int>>(); for (var i = 0; i < count; i++) { list.Add(queue.DequeueAsync()); } for (var i = 0; i < count; i++) { var task = list[i]; Assert.False(task.IsCompleted); queue.Enqueue(i); Assert.Equal(i, await task.ConfigureAwait(false)); } }
public async Task DequeueThenComplete() { var queue = new AsyncQueue<int>(); var task = queue.DequeueAsync(); Assert.False(task.IsCompleted); queue.Complete(); var threw = false; try { await task.ConfigureAwait(false); } catch (OperationCanceledException) { threw = true; } Assert.True(threw); }
public async Task DequeueAsyncWithCancellationAfterComplete() { var queue = new AsyncQueue<int>(); var cts = new CancellationTokenSource(); var task = queue.DequeueAsync(cts.Token); Assert.False(task.IsCompleted); queue.Enqueue(42); await task.ConfigureAwait(false); cts.Cancel(); }
public void DequeueAsync_handled_in_order_of_caller() { var queue = new AsyncQueue<string>(); var values = new List<string> { "A", "B", "C" }; var tasks = values.Select(_ => queue.DequeueAsync()).ToList(); for (int i = 0; i < values.Count; i++) { tasks[i].AssertNotCompleted(); queue.Enqueue(values[i]); tasks[i].AssertResult(values[i]); } }
public void First_in_first_out() { var queue = new AsyncQueue<string>(); var values = new List<string> { "A", "B", "C" }; for (int i = 0; i < values.Count; i++) { queue.Enqueue(values[i]); } for (int i = 0; i < values.Count; i++) { queue.DequeueAsync().AssertResult(values[i]); } }
public void DequeueAsync_already_canceled() { var queue = new AsyncQueue<string>(); queue.Enqueue("A"); queue.DequeueAsync(new CancellationToken(true)).AssertCanceled(); }
public void DequeueAsync_empty_canceled() { var queue = new AsyncQueue<string>(); using (var cts = new CancellationTokenSource()) { var task = queue.DequeueAsync(cts.Token); cts.Cancel(); queue.Enqueue("A"); task.AssertCanceled(); } }
public void Dequeue_should_cancel_when_cancellation_is_requested() { var cancellationTokenSource = new CancellationTokenSource(); var subject = new AsyncQueue<int>(); var result = subject.DequeueAsync(cancellationTokenSource.Token); cancellationTokenSource.Cancel(); Assert.Throws<TaskCanceledException>(() => result.GetAwaiter().GetResult()); }
public async Task DequeueManyThenComplete() { var queue = new AsyncQueue<int>(); var list = new List<Task<int>>(); for (var i = 0; i < 4; i++) { list.Add(queue.DequeueAsync()); } queue.Complete(); foreach (var task in list) { var threw = false; try { await task.ConfigureAwait(false); } catch (OperationCanceledException) { threw = true; } Assert.True(threw); } }
public async Task DequeueAfterCompleteWithData() { var queue = new AsyncQueue<int>(); queue.Enqueue(42); queue.Complete(); await queue.WhenCompletedTask.ConfigureAwait(false); Assert.Equal(42, await queue.DequeueAsync().ConfigureAwait(false)); var threw = false; try { await queue.DequeueAsync().ConfigureAwait(false); } catch (OperationCanceledException) { threw = true; } Assert.True(threw); }
public void DequeueAsyncWithCancellation() { var queue = new AsyncQueue<int>(); var cts = new CancellationTokenSource(); var task = queue.DequeueAsync(cts.Token); Assert.False(task.IsCanceled); cts.Cancel(); Assert.Equal(TaskStatus.Canceled, task.Status); }
public async Task TaskCompletesAsyncWithComplete() { var queue = new AsyncQueue<int>(); var tcs = new TaskCompletionSource<bool>(); var task = queue.DequeueAsync().ContinueWith( t => { tcs.Task.Wait(); return 0; }, default(CancellationToken), TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default); queue.Complete(); Assert.False(queue.WhenCompletedTask.IsCompleted); tcs.SetResult(true); await queue.WhenCompletedTask.ConfigureAwait(false); // The AsyncQueue<T>.Task property won't complete until all of the // existing DequeueAsync values have also completed. Assert.True(task.IsCompleted); }