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