public void TryDequeue()
{
var queue = new AsyncQueue <int>();
int value;
Assert.False(queue.TryDequeue(out value));
queue.Enqueue(13);
Assert.True(queue.TryDequeue(out value));
Assert.Equal(13, value);
}
public void Dequeue_Sync()
{
var queue = new AsyncQueue <string>();
queue.Enqueue("1");
queue.Enqueue("2");
queue.Enqueue("3");
Assert.AreEqual("1", queue.TryDequeue().Item);
Assert.AreEqual("2", queue.TryDequeue().Item);
Assert.AreEqual("3", queue.TryDequeue().Item);
}
public void Enqueue(MqttQueuedApplicationMessage queuedApplicationMessage)
{
if (queuedApplicationMessage == null)
{
throw new ArgumentNullException(nameof(queuedApplicationMessage));
}
lock (_messageQueue)
{
if (_messageQueue.Count >= _options.MaxPendingMessagesPerClient)
{
if (_options.PendingMessagesOverflowStrategy == MqttPendingMessagesOverflowStrategy.DropNewMessage)
{
return;
}
if (_options.PendingMessagesOverflowStrategy == MqttPendingMessagesOverflowStrategy.DropOldestQueuedMessage)
{
_messageQueue.TryDequeue();
}
}
_messageQueue.Enqueue(queuedApplicationMessage);
}
}
public void Count_nonempty()
{
var queue = new AsyncQueue<string>();
queue.Enqueue("A");
queue.Enqueue("B");
queue.Enqueue("C");
queue.Enqueue("D");
Assert.IsTrue(queue.TryDequeue());
Assert.AreEqual(3, queue.Count);
}
public async Task TryDequeueAfterComplete()
{
var queue = new AsyncQueue <int>();
queue.Enqueue(13);
queue.Complete();
await queue.WhenCompletedTask.ConfigureAwait(false);
int value;
Assert.True(queue.TryDequeue(out value));
Assert.Equal(13, value);
}
private static bool DequeueCompilationEvents(AsyncQueue <CompilationEvent> eventQueue, out bool compilationStartedFired, out HashSet <string> declaredSymbolNames, out HashSet <string> completedCompilationUnits)
{
compilationStartedFired = false;
declaredSymbolNames = new HashSet <string>();
completedCompilationUnits = new HashSet <string>();
if (eventQueue.Count == 0)
{
return(false);
}
CompilationEvent compEvent;
while (eventQueue.TryDequeue(out compEvent))
{
if (compEvent is CompilationStartedEvent)
{
Assert.False(compilationStartedFired, "Unexpected multiple compilation stated events");
compilationStartedFired = true;
}
else
{
var symbolDeclaredEvent = compEvent as SymbolDeclaredCompilationEvent;
if (symbolDeclaredEvent != null)
{
var symbol = symbolDeclaredEvent.Symbol;
var added = declaredSymbolNames.Add(symbol.Name);
if (!added)
{
var method = symbol as Symbols.MethodSymbol;
Assert.NotNull(method);
var isPartialMethod = method.PartialDefinitionPart != null ||
method.PartialImplementationPart != null;
Assert.True(isPartialMethod, "Unexpected multiple symbol declared events for symbol " + symbol);
}
}
else
{
var compilationCompletedEvent = compEvent as CompilationUnitCompletedEvent;
if (compilationCompletedEvent != null)
{
Assert.True(completedCompilationUnits.Add(compilationCompletedEvent.CompilationUnit.FilePath));
}
}
}
}
return(true);
}
public void Clear()
{
var queue = new AsyncQueue <string>();
queue.Enqueue("1");
queue.Enqueue("2");
queue.Enqueue("3");
queue.Clear();
Assert.AreEqual(0, queue.Count);
queue.Enqueue("4");
Assert.AreEqual(1, queue.Count);
Assert.AreEqual("4", queue.TryDequeue().Item);
}
public void TryEnqueueAndTryDequeue(int count)
{
var asyncQueue = new AsyncQueue <int>();
for (var i = 0; i < count; i++)
{
Assert.True(asyncQueue.TryEnqueue(i), "fail to send");
}
for (var i = 0; i < count; i++)
{
var value = default(int);
Assert.True(asyncQueue.TryDequeue(out value), "fail to receive");
Assert.Equal(i, value);
}
Assert.Equal(0, asyncQueue.Count);
}
public void ParallelSendAndTryDequeue(int count)
{
var asyncQueue = new AsyncQueue <int>();
var options = new ParallelOptions {
MaxDegreeOfParallelism = Environment.ProcessorCount, TaskScheduler = TaskScheduler.Default
};
var items = Enumerable.Range(0, count).ToArray();
var expectedSum = items.Sum();
Parallel.For(0, count, options, i => Assert.True(asyncQueue.TryEnqueue(i), "fail to send"));
var actualSum = 0;
var value = default(int);
while (asyncQueue.TryDequeue(out value))
{
actualSum += value;
}
Assert.Equal(expectedSum, actualSum);
Assert.Equal(0, asyncQueue.Count);
}
public async Task AsyncSendAndClose(int count)
{
var cancellation = new CancellationTokenSource(TimeSpan.FromSeconds(5));
var asyncQueue = new AsyncQueue <int>();
var sendValue = 0;
var sendTask = new Func <Task>(async() =>
{
await Task.Yield();
while (cancellation.IsCancellationRequested == false)
{
if (asyncQueue.TryEnqueue(sendValue++) == false)
{
return;
}
await Task.Delay(10).ConfigureAwait(false);
}
})().IgnoreFaultOrCancellation().ConfigureAwait(false);
await Task.Delay(count);
asyncQueue.ClearAndClose();
await sendTask;
var value = default(int);
var actualSum = 0;
while (asyncQueue.TryDequeue(out value))
{
actualSum++;
}
var expectedSum = Enumerable.Range(0, sendValue).Sum();
Assert.NotEqual(expectedSum, actualSum);
Assert.NotEqual(0, asyncQueue.Count);
cancellation.Cancel();
}
/// <summary>Events</summary>
public void Event()
{
RaiseEvent raiseEvent;
while (Events.TryDequeue(out raiseEvent))
{
// Raise start event
if (raiseEvent.EventType == EventType.Started)
{
OnStarted?.Invoke();
}
// Raise stop event
if (raiseEvent.EventType == EventType.Stopped)
{
OnStopped?.Invoke();
}
// Raise link event
if (raiseEvent.EventType == EventType.Linked)
{
OnLinked?.Invoke(raiseEvent.Link);
}
// Raise redirection event
if (raiseEvent.EventType == EventType.Redirect)
{
OnRedirect?.Invoke(raiseEvent.Link);
}
// Raise post redirection event
if (raiseEvent.EventType == EventType.Redirected)
{
OnRedirected?.Invoke(raiseEvent.Link);
}
// Raise approval event
if (raiseEvent.EventType == EventType.Approval)
{
OnApproval?.Invoke(raiseEvent.Link, raiseEvent.Content);
}
// Raise content event
if (raiseEvent.EventType == EventType.Content)
{
OnContent?.Invoke(raiseEvent.Link, raiseEvent.Content);
}
// Raise unlink event
if (raiseEvent.EventType == EventType.Unlinked)
{
OnUnlinked?.Invoke(raiseEvent.Link, raiseEvent.Reason);
}
// Raise failure event
if (raiseEvent.EventType == EventType.Failed)
{
OnFailed?.Invoke(raiseEvent.Link, raiseEvent.Failure);
}
}
}
private void FreeEventQueue(AsyncQueue<CompilationEvent> eventQueue)
{
if (eventQueue == null || ReferenceEquals(eventQueue, s_EmptyEventQueue))
{
return;
}
Debug.Assert(!eventQueue.IsCompleted);
if (eventQueue.Count > 0)
{
CompilationEvent discarded;
while (eventQueue.TryDequeue(out discarded)) ;
}
s_eventQueuePool.Free(eventQueue);
}
public void TryDequeue_nonempty()
{
var queue = new AsyncQueue<string>();
queue.Enqueue("A");
string value;
Assert.IsTrue(queue.TryDequeue(out value));
Assert.AreEqual("A", value);
Assert.AreEqual(0, queue.Count);
}
private static void FreeEventQueue(AsyncQueue<CompilationEvent> eventQueue, ObjectPool<AsyncQueue<CompilationEvent>> eventQueuePool)
{
if (eventQueue == null || ReferenceEquals(eventQueue, s_EmptyEventQueue))
{
return;
}
if (eventQueue.Count > 0)
{
CompilationEvent discarded;
while (eventQueue.TryDequeue(out discarded)) ;
}
if (!eventQueue.IsCompleted)
{
eventQueuePool.Free(eventQueue);
}
else
{
eventQueuePool.ForgetTrackedObject(eventQueue);
}
}
public async Task TryDequeueAfterComplete()
{
var queue = new AsyncQueue<int>();
queue.Enqueue(13);
queue.Complete();
await queue.WhenCompletedTask.ConfigureAwait(false);
int value;
Assert.True(queue.TryDequeue(out value));
Assert.Equal(13, value);
}
public void TryDequeue()
{
var queue = new AsyncQueue<int>();
int value;
Assert.False(queue.TryDequeue(out value));
queue.Enqueue(13);
Assert.True(queue.TryDequeue(out value));
Assert.Equal(13, value);
}
private static bool DequeueCompilationEvents(AsyncQueue<CompilationEvent> eventQueue, out bool compilationStartedFired, out HashSet<string> declaredSymbolNames, out HashSet<string> completedCompilationUnits)
{
compilationStartedFired = false;
declaredSymbolNames = new HashSet<string>();
completedCompilationUnits = new HashSet<string>();
if (eventQueue.Count == 0)
{
return false;
}
CompilationEvent compEvent;
while (eventQueue.TryDequeue(out compEvent))
{
if (compEvent is CompilationStartedEvent)
{
Assert.False(compilationStartedFired, "Unexpected multiple compilation stated events");
compilationStartedFired = true;
}
else
{
var symbolDeclaredEvent = compEvent as SymbolDeclaredCompilationEvent;
if (symbolDeclaredEvent != null)
{
var added = declaredSymbolNames.Add(symbolDeclaredEvent.Symbol.Name);
Assert.True(added, "Unexpected multiple symbol declared events for symbol " + symbolDeclaredEvent.Symbol);
}
else
{
var compilationCompeletedEvent = compEvent as CompilationUnitCompletedEvent;
if (compilationCompeletedEvent != null)
{
Assert.True(completedCompilationUnits.Add(compilationCompeletedEvent.CompilationUnit.FilePath));
}
}
}
}
return true;
}
public void TryDequeue_empty()
{
var queue = new AsyncQueue<string>();
Assert.IsFalse(queue.TryDequeue());
}