/// <summary>
/// Create an analyzer driver.
/// </summary>
/// <param name="analyzers">The set of analyzers to include in the analysis</param>
/// <param name="options">Options that are passed to analyzers</param>
/// <param name="cancellationToken">a cancellation token that can be used to abort analysis</param>
/// <param name="continueOnAnalyzerException">Delegate which is invoked when an analyzer throws an exception.
/// If a non-null delegate is provided and it returns true, then the exception is handled and converted into a diagnostic and driver continues with other analyzers.
/// Otherwise if it returns false, then the exception is not handled by the driver.
/// If null, then the driver always handles the exception.
/// </param>
protected AnalyzerDriver(ImmutableArray<IDiagnosticAnalyzer> analyzers, AnalyzerOptions options, CancellationToken cancellationToken, Func<Exception, IDiagnosticAnalyzer, bool> continueOnAnalyzerException = null)
{
this.CompilationEventQueue = new AsyncQueue<CompilationEvent>();
this.DiagnosticQueue = new AsyncQueue<Diagnostic>();
this.addDiagnostic = GetDiagnosticSinkWithSuppression();
this.analyzerOptions = options;
Func<Exception, IDiagnosticAnalyzer, bool> defaultExceptionHandler = (exception, analyzer) => true;
this.continueOnAnalyzerException = continueOnAnalyzerException ?? defaultExceptionHandler;
// start the first task to drain the event queue. The first compilation event is to be handled before
// any other ones, so we cannot have more than one event processing task until the first event has been handled.
initialWorker = Task.Run(async () =>
{
try
{
await InitialWorkerAsync(analyzers, continueOnAnalyzerException, cancellationToken).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
// If creation is cancelled we had better not use the driver any longer
this.Dispose();
}
});
}
public void TryEnqueueAfterComplete()
{
var queue = new AsyncQueue<int>();
Assert.True(queue.TryEnqueue(42));
queue.Complete();
Assert.False(queue.TryEnqueue(42));
}
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();
}
// constructors
public MultiServerCluster(ClusterSettings settings, IClusterableServerFactory serverFactory, IEventSubscriber eventSubscriber)
: base(settings, serverFactory, eventSubscriber)
{
Ensure.IsGreaterThanZero(settings.EndPoints.Count, "settings.EndPoints.Count");
if (settings.ConnectionMode == ClusterConnectionMode.Standalone)
{
throw new ArgumentException("ClusterConnectionMode.StandAlone is not supported for a MultiServerCluster.");
}
if (settings.ConnectionMode == ClusterConnectionMode.Direct)
{
throw new ArgumentException("ClusterConnectionMode.Direct is not supported for a MultiServerCluster.");
}
_monitorServersCancellationTokenSource = new CancellationTokenSource();
_serverDescriptionChangedQueue = new AsyncQueue<ServerDescriptionChangedEventArgs>();
_servers = new List<IClusterableServer>();
_state = new InterlockedInt32(State.Initial);
_replicaSetName = settings.ReplicaSetName;
eventSubscriber.TryGetEventHandler(out _closingEventHandler);
eventSubscriber.TryGetEventHandler(out _closedEventHandler);
eventSubscriber.TryGetEventHandler(out _openingEventHandler);
eventSubscriber.TryGetEventHandler(out _openedEventHandler);
eventSubscriber.TryGetEventHandler(out _addingServerEventHandler);
eventSubscriber.TryGetEventHandler(out _addedServerEventHandler);
eventSubscriber.TryGetEventHandler(out _removingServerEventHandler);
eventSubscriber.TryGetEventHandler(out _removedServerEventHandler);
}
public void DequeueAsync_before_Enqueue()
{
var queue = new AsyncQueue<string>();
var task = queue.DequeueAsync().AssertNotCompleted();
queue.Enqueue("A");
task.AssertResult("A");
}
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 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));
}
/// <summary>
/// Creates a new instance of the <see cref="AlarmAdapter"/>.
/// </summary>
public AlarmAdapter()
{
m_measurementQueue = new AsyncQueue<IEnumerable<IMeasurement>>()
{
ProcessItemFunction = ProcessMeasurements
};
m_measurementQueue.ProcessException += m_measurementQueue_ProcessException;
}
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 TryEnqueueAfterPromisingNotTo()
{
var queue = new AsyncQueue<int>();
Assert.True(queue.TryEnqueue(42));
queue.PromiseNotToEnqueue();
Assert.Throws(typeof(InvalidOperationException), () => {
queue.TryEnqueue(42);
});
}
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 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 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 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");
}
}
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);
}
private async Task ConsumeItems(
AsyncQueue<int> inputQueue,
ConcurrentBag<int> outputItems,
CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested)
{
int consumedItem = await inputQueue.DequeueAsync(cancellationToken);
outputItems.Add(consumedItem);
}
}
// constructors
public MultiServerCluster(ClusterSettings settings, IClusterableServerFactory serverFactory, IClusterListener listener)
: base(settings, serverFactory, listener)
{
Ensure.IsGreaterThanZero(settings.EndPoints.Count, "settings.EndPoints.Count");
_monitorServersCancellationTokenSource = new CancellationTokenSource();
_serverDescriptionChangedQueue = new AsyncQueue<ServerDescriptionChangedEventArgs>();
_servers = new List<IClusterableServer>();
_state = new InterlockedInt32(State.Initial);
_replicaSetName = settings.ReplicaSetName;
}
public void DequeueAll_should_dequeue_all_items(int n)
{
var subject = new AsyncQueue<int>();
for (var i = 0; i < n; i++)
{
subject.Enqueue(i);
}
var count = subject.DequeueAll().Count();
count.Should().Be(n);
}
/// <summary>
/// Initializes a new instance of the <see cref="MetricImporter"/> class.
/// </summary>
public MetricImporter()
{
m_fileProcessQueue = new AsyncQueue<string>();
m_fileProcessQueue.ProcessItemFunction = ProcessFile;
m_fileProcessQueue.ProcessException += m_fileProcessQueue_ProcessException;
m_columns = new Dictionary<string, int>(StringComparer.CurrentCultureIgnoreCase);
m_columnMappings = new Dictionary<int, IMeasurement>();
m_inputInterval = 5.0D;
m_measurementsPerInterval = 5;
m_skipRows = 4;
m_timestampFormat = "dd-MMM-yyyy HH:mm:ss.fff";
// Set minimum timer resolution to one millisecond to improve timer accuracy
PrecisionTimer.SetMinimumTimerResolution(1);
}
public void TestAssignActor_RegistersActorHandlers()
{
var actorRegistrationsQueue = new AsyncQueue<IActor>();
var actorHost = new ActorHost(new SocketFactory(null),
actorHandlersMap,
new AsyncQueue<AsyncMessageContext>(),
actorRegistrationsQueue,
routerConfiguration,
messageTracer.Object,
logger);
actorHost.AssignActor(new EchoActor());
var registration = actorRegistrationsQueue.GetConsumingEnumerable(CancellationToken.None).First();
Assert.IsTrue(registration.GetInterfaceDefinition().Any(id => id.Message.Identity == SimpleMessage.MessageIdentity));
Assert.IsTrue(registration.GetInterfaceDefinition().Any(id => id.Message.Version == Message.CurrentVersion));
}
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);
}
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 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));
}
}
async void RunBluetoothListener()
{
BluetoothListener listener;
try
{
listener = new BluetoothListener(new Guid("{05e9b9dd-1688-4785-bb1d-1c750034157b}"));
listener.Start();
}
catch
{
MessageBox.Show($"Unable to connect to bluetooth");
return;
}
while (true)
{
var neoSocket = new NeoSocket(await Task.Run(() => listener.AcceptBluetoothClient()));
var queue = new AsyncQueue <byte[]>();
Reader(neoSocket, queue);
Writer(neoSocket, queue);
}
}
public async Task AsyncQueueSynchronizesAccess()
{
ConcurrentBag<int> outputItems = new ConcurrentBag<int>();
AsyncQueue<int> inputQueue = new AsyncQueue<int>(Enumerable.Range(0, 100));
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
try
{
// Start 5 consumers
await Task.WhenAll(
Task.Run(() => ConsumeItems(inputQueue, outputItems, cancellationTokenSource.Token)),
Task.Run(() => ConsumeItems(inputQueue, outputItems, cancellationTokenSource.Token)),
Task.Run(() => ConsumeItems(inputQueue, outputItems, cancellationTokenSource.Token)),
Task.Run(() => ConsumeItems(inputQueue, outputItems, cancellationTokenSource.Token)),
Task.Run(() => ConsumeItems(inputQueue, outputItems, cancellationTokenSource.Token)),
Task.Run(
async () =>
{
// Wait for a bit and then add more items to the queue
await Task.Delay(250);
foreach (var i in Enumerable.Range(100, 200))
{
await inputQueue.EnqueueAsync(i);
}
// Cancel the waiters
cancellationTokenSource.Cancel();
}));
}
catch (TaskCanceledException)
{
// Do nothing, this is expected.
}
// At this point, numbers 0 through 299 should be in the outputItems
IEnumerable<int> expectedItems = Enumerable.Range(0, 300);
Assert.Equal(0, expectedItems.Except(outputItems).Count());
}
public void ReportHangOnRunAsyncThenJoin()
{
this.Factory.HangDetectionTimeout = TimeSpan.FromMilliseconds(10);
var releaseTaskSource = new TaskCompletionSource <object>();
var hangQueue = new AsyncQueue <TimeSpan>();
this.Context.OnReportHang = (hangDuration, iterations, id) =>
{
hangQueue.Enqueue(hangDuration);
};
Task.Run(async delegate
{
var ct = new CancellationTokenSource(TestTimeout).Token;
try
{
TimeSpan lastDuration = TimeSpan.Zero;
for (int i = 0; i < 3; i++)
{
var duration = await hangQueue.DequeueAsync(ct);
Assert.True(lastDuration == TimeSpan.Zero || lastDuration < duration);
lastDuration = duration;
}
releaseTaskSource.SetResult(null);
}
catch (Exception ex)
{
releaseTaskSource.SetException(ex);
}
}).Forget();
var joinableTask = this.Factory.RunAsync(async delegate
{
await releaseTaskSource.Task;
});
joinableTask.Join();
}
public BlockStoreSignaled(
IBlockStoreQueue blockStoreQueue,
ConcurrentChain chain,
StoreSettings storeSettings,
IChainState chainState,
IConnectionManager connection,
INodeLifetime nodeLifetime,
ILoggerFactory loggerFactory,
IInitialBlockDownloadState initialBlockDownloadState)
{
this.blockStoreQueue = blockStoreQueue;
this.chain = chain;
this.chainState = chainState;
this.connection = connection;
this.nodeLifetime = nodeLifetime;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.storeSettings = storeSettings;
this.initialBlockDownloadState = initialBlockDownloadState;
this.blocksToAnnounce = new AsyncQueue <ChainedHeader>();
this.dequeueLoopTask = this.DequeueContinuouslyAsync();
}
public FederationWalletSyncManager(ILoggerFactory loggerFactory, IFederationWalletManager walletManager, ChainIndexer chain,
Network network, IBlockStore blockStore, StoreSettings storeSettings, INodeLifetime nodeLifetime)
{
Guard.NotNull(loggerFactory, nameof(loggerFactory));
Guard.NotNull(walletManager, nameof(walletManager));
Guard.NotNull(chain, nameof(chain));
Guard.NotNull(network, nameof(network));
Guard.NotNull(blockStore, nameof(blockStore));
Guard.NotNull(storeSettings, nameof(storeSettings));
Guard.NotNull(nodeLifetime, nameof(nodeLifetime));
this.walletManager = walletManager;
this.chain = chain;
this.blockStore = blockStore;
this.coinType = (CoinType)network.Consensus.CoinType;
this.storeSettings = storeSettings;
this.nodeLifetime = nodeLifetime;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.blocksQueue = new AsyncQueue <Block>(this.OnProcessBlockAsync);
this.blocksQueueSize = 0;
}
public void TestQueuedSymbols()
{
var source =
@"namespace N
{
partial class C<T1>
{
partial void M(int x1);
internal int P { get; private set; }
int F = 12;
void N<T2>(int y = 12) { F = F + 1; }
}
partial class C<T1>
{
partial void M(int x2) {}
}
}";
var q = new AsyncQueue <CompilationEvent>();
CreateCompilationWithMscorlib45(source)
.WithEventQueue(q)
.VerifyDiagnostics() // force diagnostics twice
.VerifyDiagnostics();
VerifyEvents(q,
"CompilationStartedEvent",
"SymbolDeclaredCompilationEvent(P int C<T1>.P @ : (5,4)-(5,40))",
"SymbolDeclaredCompilationEvent(F int C<T1>.F @ : (6,8)-(6,14))",
"SymbolDeclaredCompilationEvent(C C<T1> @ : (2,2)-(8,3), : (9,2)-(12,3))",
"SymbolDeclaredCompilationEvent(M void C<T1>.M(int x1) @ : (4,4)-(4,27))",
"SymbolDeclaredCompilationEvent(M void C<T1>.M(int x2) @ : (11,4)-(11,29))",
"SymbolDeclaredCompilationEvent(N N @ : (0,0)-(13,1))",
"SymbolDeclaredCompilationEvent(<empty> @ : (0,0)-(13,1))",
"SymbolDeclaredCompilationEvent(get_P int C<T1>.P.get @ : (5,21)-(5,25))",
"SymbolDeclaredCompilationEvent(set_P void C<T1>.P.set @ : (5,26)-(5,38))",
"SymbolDeclaredCompilationEvent(N void C<T1>.N<T2>(int y = 12) @ : (7,4)-(7,41))",
"CompilationUnitCompletedEvent()",
"CompilationCompletedEvent"
);
}
public BlockStoreSignaled(
BlockStoreLoop blockStoreLoop,
ConcurrentChain chain,
StoreSettings storeSettings,
IChainState chainState,
IConnectionManager connection,
INodeLifetime nodeLifetime,
ILoggerFactory loggerFactory,
IBlockStoreCache blockStoreCache)
{
this.blockStoreLoop = blockStoreLoop;
this.chain = chain;
this.chainState = chainState;
this.connection = connection;
this.nodeLifetime = nodeLifetime;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.storeSettings = storeSettings;
this.blockStoreCache = blockStoreCache;
this.blocksToAnnounce = new AsyncQueue <ChainedBlock>();
this.dequeueLoopTask = this.DequeueContinuouslyAsync();
}
public async Task DequeueAsync_GivenMultipleDequeues_ShouldCompleteInOrderedSequence()
{
//Arrange
const int value1 = 1, value2 = 2;
var queue = new AsyncQueue <int>();
var dequeue1 = queue.Dequeue();
var dequeue2 = queue.Dequeue();
queue.Enqueue(value1);
queue.Enqueue(value2);
//Act
var actual1 = await dequeue1;
var actual2 = await dequeue2;
//Assert
Assert.Equal(value1, actual1);
Assert.Equal(value2, actual2);
//Annihilate
queue.Dispose();
}
public Day15()
{
AsyncQueue <long> programInputs = new AsyncQueue <long>();
AsyncQueue <long> programOutputs = new AsyncQueue <long>();
IntCodeAsync intCode = new IntCodeAsync(_program, programInputs.Dequeue, programOutputs.Enqueue);
Task vm = Task.Run(intCode.RunAsync);
Task <long> sendCommand(Direction d)
{
programInputs.Enqueue((long)d + 1);
return(programOutputs.Dequeue());
}
async Task backtrackHelper(IntVec2 position)
{
foreach (Direction d in s_directions)
{
IntVec2 candidatePosition = position + s_deltas[(int)d];
if (!_map.ContainsKey(candidatePosition))
{
Status status = (Status) await sendCommand(d);
if (status != Status.Wall)
{
_map.Add(candidatePosition, status);
if (status == Status.Oxygen)
{
_oxygen = candidatePosition;
}
await backtrackHelper(candidatePosition);
await sendCommand(s_opposites[(int)d]);
}
}
}
}
Task.Run(() => backtrackHelper(IntVec2.Zero)).Wait();
}
public async Task AsyncQueue_DisposeCancelsEnqueueAsync()
{
bool signal = false;
var asyncQueue = new AsyncQueue <int>(async(item, cancellation) =>
{
// We set the signal and wait and if the wait is finished, we reset the signal, but that should not happen.
signal = true;
await Task.Delay(500, cancellation);
signal = false;
});
// Enqueue an item, which should trigger the callback.
asyncQueue.Enqueue(1);
// Wait a bit and dispose the queue, which should trigger the cancellation.
await Task.Delay(100);
asyncQueue.Dispose();
Assert.True(signal);
}
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);
}
async void RunTcpListener(int port)
{
TcpListener listener;
try
{
listener = new TcpListener(IPAddress.Any, port);
listener.Start();
}
catch
{
MessageBox.Show($"Unable to connect to port {port}");
return;
}
while (true)
{
var neoSocket = new NeoSocket(await listener.AcceptTcpClientAsync());
var queue = new AsyncQueue <byte[]>();
Reader(neoSocket, queue);
Writer(neoSocket, queue);
}
}
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>
/// Initializes parts of the object that are common for both inbound and outbound peers.
/// </summary>
/// <param name="inbound"><c>true</c> for inbound peers, <c>false</c> for outbound peers.</param>
/// <param name="peerEndPoint">IP address and port on the side of the peer.</param>
/// <param name="network">Specification of the network the node runs on - regtest/testnet/mainnet.</param>
/// <param name="parameters">Various settings and requirements related to how the connections with peers are going to be established, or <c>null</c> to use default parameters.</param>
/// <param name="dateTimeProvider">Provider of time functions.</param>
/// <param name="loggerFactory">Factory for creating loggers.</param>
/// <param name="selfEndpointTracker">Tracker for endpoints known to be self.</param>
/// <param name="onDisconnected">Callback that is invoked when peer has finished disconnecting, or <c>null</c> when no notification after the disconnection is required.</param>
private NetworkPeer(bool inbound,
IPEndPoint peerEndPoint,
Network network,
NetworkPeerConnectionParameters parameters,
IDateTimeProvider dateTimeProvider,
ILoggerFactory loggerFactory,
ISelfEndpointTracker selfEndpointTracker,
Action <INetworkPeer> onDisconnected = null,
Action <IPEndPoint, Payload> onSendingMessage = null)
{
this.dateTimeProvider = dateTimeProvider;
this.preferredTransactionOptions = parameters.PreferredTransactionOptions;
this.SupportedTransactionOptions = parameters.PreferredTransactionOptions & ~TransactionOptions.All;
this.State = inbound ? NetworkPeerState.Connected : NetworkPeerState.Created;
this.Inbound = inbound;
this.PeerEndPoint = peerEndPoint;
this.RemoteSocketEndpoint = this.PeerEndPoint;
this.RemoteSocketAddress = this.RemoteSocketEndpoint.Address;
this.RemoteSocketPort = this.RemoteSocketEndpoint.Port;
this.Network = network;
this.Behaviors = new List <INetworkPeerBehavior>();
this.selfEndpointTracker = selfEndpointTracker;
this.onDisconnectedAsyncContext = new AsyncLocal <DisconnectedExecutionAsyncContext>();
this.ConnectionParameters = parameters ?? new NetworkPeerConnectionParameters();
this.MyVersion = this.ConnectionParameters.CreateVersion(this.selfEndpointTracker.MyExternalAddress, this.PeerEndPoint, network, this.dateTimeProvider.GetTimeOffset());
this.MessageReceived = new AsyncExecutionEvent <INetworkPeer, IncomingMessage>();
this.StateChanged = new AsyncExecutionEvent <INetworkPeer, NetworkPeerState>();
this.onDisconnected = onDisconnected;
this.onSendingMessage = onSendingMessage;
this.asyncQueue = new AsyncQueue <Payload>(this.SendMessageHandledAsync);
}
public static async Task RunAsyncQueueAsync(int count)
{
var cancellationToken = CancellationToken.None;
var target = new AsyncQueue <string>(count, count);
var PostTasks = new Task[count];
var dequeueTasks = new Task <string> [count];
var PostSetupTask = Task.Run(() =>
{
for (int i = 0; i < count; i++)
{
var item = "HVQFSW613ACT65DOS2ILBA4G4QB3UP3K4PPZPB7UZ771SX9TX7DVNZR82W1TSHWDBZHIE8V6CGILADRFQ3QA76BOYA4T3XS7A8OQ3I2FCT8X04L2GXR3RY23WB2A0ZLNT58WCMZTY54PRPOVVENCMOJMCZC6D85H9HPGJ58BBOHN7PJ0G3QTDSB8K4ACT26QXG5D30WI";
PostTasks[i] = Task.Run(() => target.Post(item));
}
});
var dequeueSetupTask = Task.Run(() =>
{
for (int i = 0; i < count; i++)
{
dequeueTasks[i] = target.ReceiveAsync(cancellationToken);
}
});
await Task.WhenAll(PostSetupTask, dequeueSetupTask);
await Task.WhenAll(dequeueTasks);
await Task.WhenAll(PostTasks);
if (target.BufferCount != 0 ||
target.PromisesCount != 0)
{
System.Console.WriteLine("AsyncQueue - Not empty");
}
}
public async Task WriteNotifications(Func <string, bool> shouldWriteByDb)
{
var receiveBuffer = new ArraySegment <byte>(new byte[1024]);
var receive = _webSocket.ReceiveAsync(receiveBuffer, _resourceShutdown);
var asyncQueue = new AsyncQueue <DynamicJsonValue>();
try
{
using (_notificationsBase.TrackActions(asyncQueue, this, shouldWriteByDb))
{
AfterTrackActionsRegistration?.Invoke();
while (_resourceShutdown.IsCancellationRequested == false)
{
// we use this to detect client-initialized closure
if (receive.IsCompleted)
{
break;
}
var tuple = await asyncQueue.TryDequeueAsync(TimeSpan.FromSeconds(5));
if (tuple.Item1 == false)
{
await SendHeartbeat();
continue;
}
await WriteToWebSocket(tuple.Item2);
}
}
}
catch (OperationCanceledException)
{
}
}
public HttpNegotiationQueue(WebSocketFactoryCollection standards, WebSocketConnectionExtensionCollection extensions, WebSocketListenerOptions options)
{
if (standards == null)
{
throw new ArgumentNullException(nameof(standards));
}
if (extensions == null)
{
throw new ArgumentNullException(nameof(extensions));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
this.log = options.Logger;
_options = options;
_extensions = extensions;
_cancel = new CancellationTokenSource();
_semaphore = new SemaphoreSlim(options.ParallelNegotiations);
_connections = new AsyncQueue <NetworkConnection>(options.NegotiationQueueCapacity);
_negotiations = new AsyncQueue <WebSocketNegotiationResult>();
_negotiations.ParallelTakeErrorMessage = $"Parallel call to '{nameof(WebSocketListener.AcceptWebSocketAsync)}' is not allowed.";
_negotiations.ClosedErrorMessage = $"{nameof(WebSocketListener)} is closed and will not accept new connections.";
//_cancel.Token.Register(() => this._connections.Close(new OperationCanceledException()));
_handShaker = new WebSocketHandshaker(standards, _options);
if (options.PingMode != PingMode.Manual)
{
this.pingQueue = new PingQueue(options.PingInterval);
}
WorkAsync().LogFault(this.log);
}
static void Main(string[] args)
{
var queue = AsyncQueue.Create <string>();
var source = new CancellationTokenSource();
var token = source.Token;
queue.Enqueue("1").Wait();
queue.Enqueue("2").Wait();
queue.Enqueue("3").Wait();
queue.Enqueue("4").Wait();
queue.Enqueue("5").Wait();
queue.Enqueue("6").Wait();
queue.Enqueue("7").Wait();
queue.MaxCapacity = 2;
queue.OverflowRule = OverflowRule.DiscardFirst;
queue.Enqueue("8").Wait();
var senders = Enumerable.Range(0, 3).Select(index => new Sender(index, queue, (ConsoleColor)(index + 13))).ToArray();
var receivers = Enumerable.Range(0, 10).Select(index => new Receiver(index, queue, (ConsoleColor)(index + 5))).ToArray();
Parallel.ForEach(receivers, async x => await x.Receive(token));
Thread.Sleep(1000);
var message = 0;
Parallel.ForEach(senders, async x =>
{
for (var i = 0; i < 2000; i++)
{
await x.Send(Interlocked.Increment(ref message).ToString());
}
});
Console.ReadLine();
source.Cancel();
Console.ReadLine();
}
public void Should_send_postponed_notification_when_postpone_date_reached()
{
using (var database = CreateDocumentDatabase())
{
database.NotificationCenter.Options.DatabaseStatsThrottle = TimeSpan.MaxValue;
var alert1 = GetSampleAlert(customKey: "alert-1");
database.NotificationCenter.Add(alert1);
var alert2 = GetSampleAlert(customKey: "alert-2");
database.NotificationCenter.Add(alert2);
var alert3 = GetSampleAlert(customKey: "alert-3");
database.NotificationCenter.Add(alert3);
var actions = new AsyncQueue <DynamicJsonValue>();
var writer = new TestWebSocketWriter();
using (database.NotificationCenter.TrackActions(actions, writer))
{
database.NotificationCenter.Postpone(alert1.Id, SystemTime.UtcNow.AddDays(1));
database.NotificationCenter.Postpone(alert2.Id, SystemTime.UtcNow.AddMilliseconds(100));
database.NotificationCenter.Postpone(alert3.Id, SystemTime.UtcNow.AddDays(1));
for (int i = 0; i < 2; i++)
{
var posponed = actions.DequeueAsync().Result;
Assert.NotNull(posponed);
Assert.Equal(NotificationUpdateType.Postponed, posponed[(nameof(NotificationUpdated.UpdateType))]);
}
Assert.True(SpinWait.SpinUntil(() => writer.SentNotifications.Count == 1, TimeSpan.FromSeconds(30)), $"Got: {writer.SentNotifications.Count}");
Assert.Equal(alert2.Id, writer.SentNotifications[0]);
}
}
}
public async Task DequeueAsync_GivenMultipleDequeues_ShouldCompleteInOrderedSequence()
{
//Arrange
const int expected1 = 1, expected2 = 2;
var queue = new AsyncQueue <int>();
var dequeue1 = queue.Dequeue();
var dequeue2 = queue.Dequeue();
queue.Enqueue(expected1);
queue.Enqueue(expected2);
//Act
var actual1 = await dequeue1.ConfigureAwait(false);
var actual2 = await dequeue2.ConfigureAwait(false);
//Assert
actual1.Should().Be(expected1);
actual2.Should().Be(expected2);
//Annihilate
queue.Dispose();
}
public void TestEarlyCancellation()
{
var source =
@"
namespace N1
{
partial class Class
{
private void NonPartialMethod1() { }
partial void PartialMethod();
}
}
";
var tree = CSharpSyntaxTree.ParseText(source, path: "file1");
var eventQueue = new AsyncQueue <CompilationEvent>();
var compilation = CreateCompilationWithMscorlib45(new[] { tree })
.WithEventQueue(eventQueue);
eventQueue.TryComplete(); // complete the queue before the compiler is finished with it
var model = compilation.GetSemanticModel(tree);
model.GetDiagnostics(tree.GetRoot().FullSpan);
}
public void Can_postpone_notification_forever_then_next_notifictions_wont_be_sent()
{
using (var database = CreateDocumentDatabase())
{
database.NotificationCenter.Options.DatabaseStatsThrottle = TimeSpan.MaxValue;
var alert = GetSampleAlert();
database.NotificationCenter.Add(alert);
var notifications = new AsyncQueue <DynamicJsonValue>();
var writer = new TestWebSocketWriter();
database.NotificationCenter.Postpone(alert.Id, DateTime.MaxValue);
using (database.NotificationCenter.TrackActions(notifications, writer))
{
database.NotificationCenter.Add(alert);
Assert.Equal(0, notifications.Count);
}
}
}
private async Task NewConnectionsHandler(AsyncQueue <OwnTcpSendMessage> processQueue)
{
try
{
while (IsOpen)
{
TcpClient client = await listener.AcceptTcpClientAsync().ConfigureAwait(false);
OwnTcpSendQueue queue = new OwnTcpSendQueue();
OwnTcpServerConnection connection = new OwnTcpServerConnection(client, queue);
connections.Add(connection);
Task sendTask = Task.Run(() => SendClientHandler(connection));
Task readTask = Task.Run(() => ReadClientHandler(connection, processQueue));
connection.Task = Task.WhenAll(sendTask, readTask);
}
}
catch (Exception e)
{
await CloseAsync(e, false);
}
}
static void Main(string[] args)
{
finishedTokenQ = new AsyncQueue <int>();
int receivePort = 1001;
int sendPort = 1000;
string clientInstanceName = "client2";
string serverInstanceName = "server1";
Client2 client = new Client2(serverInstanceName);
using (var c = AmbrosiaFactory.Deploy <IClient2.IClient2>(clientInstanceName, client, receivePort, sendPort))
{
while (finishedTokenQ.IsEmpty)
{
Console.Write("Enter a message (hit ENTER to send): ");
string input = Console.ReadLine();
client.IngressKeyboardInput(input);
Thread.Sleep(1000);
}
finishedTokenQ.DequeueAsync().Wait();
}
}
public async Task Enumerate()
{
var queue = new AsyncQueue <int>();
var list = new List <int>();
var task = Task.Run(async() =>
{
await foreach (var i in queue)
{
list.Add(i);
}
});
for (var i = 0; i < 100; i++)
{
Assert.That(queue.TryWrite(i), Is.True);
}
queue.Complete();
await task;
Assert.That(list.Count, Is.EqualTo(100));
}
public static async Task RunAsyncQueueAsync(int count)
{
var cancellationToken = CancellationToken.None;
var target = new AsyncQueue<string>(count, count);
var PostTasks = new Task[count];
var dequeueTasks = new Task<string>[count];
var PostSetupTask = Task.Run(() =>
{
for (int i = 0; i < count; i++)
{
var item = "HVQFSW613ACT65DOS2ILBA4G4QB3UP3K4PPZPB7UZ771SX9TX7DVNZR82W1TSHWDBZHIE8V6CGILADRFQ3QA76BOYA4T3XS7A8OQ3I2FCT8X04L2GXR3RY23WB2A0ZLNT58WCMZTY54PRPOVVENCMOJMCZC6D85H9HPGJ58BBOHN7PJ0G3QTDSB8K4ACT26QXG5D30WI";
PostTasks[i] = Task.Run(() => target.Post(item));
}
});
var dequeueSetupTask = Task.Run(() =>
{
for (int i = 0; i < count; i++)
{
dequeueTasks[i] = target.ReceiveAsync(cancellationToken);
}
});
await Task.WhenAll(PostSetupTask, dequeueSetupTask);
await Task.WhenAll(dequeueTasks);
await Task.WhenAll(PostTasks);
if (target.BufferCount != 0 ||
target.PromisesCount != 0)
{
System.Console.WriteLine("AsyncQueue - Not empty");
}
}
public async static void Run(string slidesQuery, string size, Action <string> action, CancellationToken token)
{
if (string.IsNullOrWhiteSpace(slidesQuery))
{
return;
}
var inputQueries = new AsyncQueue <string>();
slidesQuery.Split('\n').ToList().ForEach(query => inputQueries.Enqueue(query));
inputQueries.SetFinished();
var outputURLs = new AsyncQueue <List <string> >();
AsyncHelper.RunTasks(inputQueries, query => GetSlideURLs(query, size, token), outputURLs, token);
var urls = new List <string>();
while (await outputURLs.HasItemsAsync(token))
{
foreach (var item in outputURLs.Dequeue())
{
urls.Add(item);
}
}
var random = new Random();
urls = urls.OrderBy(x => random.Next()).ToList();
var inputURLs = new AsyncQueue <string>();
urls.ForEach(url => inputURLs.Enqueue(url));
inputURLs.SetFinished();
SlideDownloader.Run(inputURLs, action, token);
}
private PhpCompilation(
string assemblyName,
PhpCompilationOptions options,
ImmutableArray <MetadataReference> references,
bool isSubmission,
ReferenceManager referenceManager = null,
bool reuseReferenceManager = false,
//SyntaxAndDeclarationManager syntaxAndDeclarations
AsyncQueue <CompilationEvent> eventQueue = null
)
: base(assemblyName, references, SyntaxTreeCommonFeatures(ImmutableArray <SyntaxTree> .Empty), isSubmission, eventQueue)
{
_wellKnownMemberSignatureComparer = new WellKnownMembersSignatureComparer(this);
_options = options;
_tables = new SourceSymbolCollection(this);
_coreTypes = new CoreTypes(this);
_coreMethods = new CoreMethods(_coreTypes);
_anonymousTypeManager = new AnonymousTypeManager(this);
_referenceManager = (reuseReferenceManager && referenceManager != null)
? referenceManager
: new ReferenceManager(MakeSourceAssemblySimpleName(), options.AssemblyIdentityComparer, referenceManager?.ObservedMetadata, options.SdkDirectory);
}
public BlockStoreQueue(
IBlockRepository blockRepository,
ConcurrentChain chain,
IChainState chainState,
StoreSettings storeSettings,
INodeLifetime nodeLifetime,
ILoggerFactory loggerFactory)
{
Guard.NotNull(blockRepository, nameof(blockRepository));
Guard.NotNull(chain, nameof(chain));
Guard.NotNull(chainState, nameof(chainState));
Guard.NotNull(storeSettings, nameof(storeSettings));
Guard.NotNull(nodeLifetime, nameof(nodeLifetime));
Guard.NotNull(loggerFactory, nameof(loggerFactory));
this.chainState = chainState;
this.nodeLifetime = nodeLifetime;
this.storeSettings = storeSettings;
this.chain = chain;
this.blockRepository = blockRepository;
this.blocksQueue = new AsyncQueue <BlockPair>();
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
}
public async Task ParallelSendAndCloseReceiveAll(int count)
{
var cancellationSource = new CancellationTokenSource();
var asyncQueue = new AsyncQueue <int>();
var options = new ParallelOptions {
CancellationToken = cancellationSource.Token, MaxDegreeOfParallelism = Environment.ProcessorCount / 2, TaskScheduler = TaskScheduler.Default
};
var items = new ConcurrentQueue <int>(Enumerable.Range(0, count));
var sendTask = Task.Factory.StartNew(() => Parallel.For(0, count, options, i =>
{
var item = default(int);
if (items.TryDequeue(out item))
{
if (asyncQueue.TryEnqueue(item) == false)
{
items.Enqueue(item);
}
}
}));
await Task.Delay(1).ConfigureAwait(false);
var itemsInAsyncQueue = asyncQueue.TakeAllAndClose(); // deny TryEnqueue
cancellationSource.Cancel(); // stop parallel for
await sendTask.IgnoreFaultOrCancellation().ConfigureAwait(false);
var actualCount = items.Count + itemsInAsyncQueue.Count;
this.logger.Debug($"[TEST] en-queued: {itemsInAsyncQueue.Count}, total: {count}");
Assert.Equal(count, actualCount);
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];
}
using (var c = AmbrosiaFactory.Deploy <IClient3>(clientInstanceName, new Client3(serverInstanceName), receivePort, sendPort))
{
finishedTokenQ.DequeueAsync().Wait();
}
}
public async Task Duplicated_notification_should_not_arrive_before_postponed_until_date()
{
using (var database = CreateDocumentDatabase())
{
database.NotificationCenter.Options.DatabaseStatsThrottle = TimeSpan.MaxValue;
var alert = GetSampleAlert();
database.NotificationCenter.Add(alert);
database.NotificationCenter.Postpone(alert.Id, SystemTime.UtcNow.AddDays(1));
var actions = new AsyncQueue <DynamicJsonValue>();
var writer = new TestWebSocketWriter();
using (database.NotificationCenter.TrackActions(actions, writer))
{
database.NotificationCenter.Add(alert);
Assert.False((await actions.TryDequeueAsync(TimeSpan.FromMilliseconds(10))).Item1);
database.NotificationCenter.Add(alert);
Assert.False((await actions.TryDequeueAsync(TimeSpan.FromMilliseconds(10))).Item1);
}
}
}
/// <summary>
/// Returns a new compilation with a given event queue.
/// </summary>
public override Compilation WithEventQueue(AsyncQueue<CompilationEvent> eventQueue)
{
return new CSharpCompilation(
this.AssemblyName,
this.options,
this.ExternalReferences,
this.SyntaxTrees,
this.syntaxTreeOrdinalMap,
this.rootNamespaces,
this.declarationTable,
this.previousSubmission,
this.SubmissionReturnType,
this.HostObjectType,
this.IsSubmission,
this.referenceManager,
reuseReferenceManager: true,
eventQueue: eventQueue);
}
private CSharpCompilation(
string assemblyName,
CSharpCompilationOptions options,
ImmutableArray<MetadataReference> references,
ImmutableArray<SyntaxTree> syntaxTrees,
ImmutableDictionary<SyntaxTree, int> syntaxTreeOrdinalMap,
ImmutableDictionary<SyntaxTree, Lazy<RootSingleNamespaceDeclaration>> rootNamespaces,
DeclarationTable declarationTable,
CSharpCompilation previousSubmission,
Type submissionReturnType,
Type hostObjectType,
bool isSubmission,
ReferenceManager referenceManager,
bool reuseReferenceManager,
AsyncQueue<CompilationEvent> eventQueue = null)
: base(assemblyName, references, submissionReturnType, hostObjectType, isSubmission, syntaxTreeOrdinalMap, eventQueue)
{
using (Logger.LogBlock(FunctionId.CSharp_Compilation_Create, message: assemblyName))
{
this.wellKnownMemberSignatureComparer = new WellKnownMembersSignatureComparer(this);
this.options = options;
this.syntaxTrees = syntaxTrees;
this.rootNamespaces = rootNamespaces;
this.declarationTable = declarationTable;
Debug.Assert(syntaxTrees.All(tree => syntaxTrees[syntaxTreeOrdinalMap[tree]] == tree));
Debug.Assert(syntaxTrees.SetEquals(rootNamespaces.Keys.AsImmutable(), EqualityComparer<SyntaxTree>.Default));
this.builtInOperators = new BuiltInOperators(this);
this.scriptClass = new Lazy<ImplicitNamedTypeSymbol>(BindScriptClass);
this.globalImports = new Lazy<Imports>(BindGlobalUsings);
this.globalNamespaceAlias = new Lazy<AliasSymbol>(CreateGlobalNamespaceAlias);
this.anonymousTypeManager = new AnonymousTypeManager(this);
if (isSubmission)
{
Debug.Assert(previousSubmission == null || previousSubmission.HostObjectType == hostObjectType);
this.previousSubmission = previousSubmission;
}
else
{
Debug.Assert(previousSubmission == null && submissionReturnType == null && hostObjectType == null);
}
if (reuseReferenceManager)
{
referenceManager.AssertCanReuseForCompilation(this);
this.referenceManager = referenceManager;
}
else
{
this.referenceManager = new ReferenceManager(
MakeSourceAssemblySimpleName(),
options.AssemblyIdentityComparer,
(referenceManager != null) ? referenceManager.ObservedMetadata : null);
}
Debug.Assert((object)this.lazyAssemblySymbol == null);
if (EventQueue != null) EventQueue.Enqueue(new CompilationStartedEvent(this));
}
}
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 TestCompilationEventsForPartialMethod()
{
var source1 = @"
namespace N1
{
partial class Class
{
private void NonPartialMethod1() { }
partial void PartialMethod();
}
}
";
var source2 = @"
namespace N1
{
partial class Class
{
private void NonPartialMethod2() { }
partial void PartialMethod() { }
}
}
";
var tree1 = CSharpSyntaxTree.ParseText(source1, path: "file1");
var tree2 = CSharpSyntaxTree.ParseText(source2, path: "file2");
var eventQueue = new AsyncQueue<CompilationEvent>();
var compilation = CreateCompilationWithMscorlib45(new[] { tree1, tree2 }).WithEventQueue(eventQueue);
// Invoke SemanticModel.GetDiagnostics to force populate the event queue for symbols in the first source file.
var model = compilation.GetSemanticModel(tree1);
model.GetDiagnostics(tree1.GetRoot().FullSpan);
Assert.True(eventQueue.Count > 0);
bool compilationStartedFired;
HashSet<string> declaredSymbolNames, completedCompilationUnits;
Assert.True(DequeueCompilationEvents(eventQueue, out compilationStartedFired, out declaredSymbolNames, out completedCompilationUnits));
// Verify symbol declared events fired for all symbols declared in the first source file.
Assert.True(compilationStartedFired);
Assert.True(declaredSymbolNames.Contains(compilation.GlobalNamespace.Name));
Assert.True(declaredSymbolNames.Contains("N1"));
Assert.True(declaredSymbolNames.Contains("Class"));
Assert.True(declaredSymbolNames.Contains("NonPartialMethod1"));
Assert.True(declaredSymbolNames.Contains("PartialMethod"));
Assert.True(completedCompilationUnits.Contains(tree1.FilePath));
}
